r146

docs/api/en/core/Object3D.html

@@ -324,7 +324,7 @@
 		This method does not support objects having non-uniformly-scaled parent(s).
 		</p>
 
-		<h3>[method:Array raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
+		<h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
 		<p>
 		Abstract (empty) method to get intersections between a casted ray and this object.
 		Subclasses such as [page:Mesh], [page:Line], and [page:Points] implement this method in order
@@ -470,7 +470,13 @@
 		<p>Updates the local transform.</p>
 
 		<h3>[method:undefined updateMatrixWorld]( [param:Boolean force] )</h3>
-		<p>Updates the global transform of the object and its descendants.</p>
+		<p>
+		force - A boolean that can be used to bypass [page:.matrixWorldAutoUpdate],
+		to recalculate the world matrix of the object and descendants on the current frame.
+		Useful if you cannot wait for the renderer to update it on the next frame (assuming [page:.matrixWorldAutoUpdate] set to `true`).<br /><br />
+
+		Updates the global transform of the object and its descendants if the world matrix needs update ([page:.matrixWorldNeedsUpdate] set to true) or if the `force` parameter is set to `true`.
+		</p>
 
 		<h3>[method:undefined updateWorldMatrix]( [param:Boolean updateParents], [param:Boolean updateChildren] )</h3>
 		<p>

docs/api/en/materials/MeshLambertMaterial.html

@@ -16,7 +16,7 @@
 
 			The material uses a non-physically based [link:https://en.wikipedia.org/wiki/Lambertian_reflectance Lambertian]
 			model for calculating reflectance. This can simulate some surfaces (such as untreated wood or stone) well,
-			but cannot simulate shiny surfaces with specular highlights (such as varnished wood). [name] uses per-fragmet shading.<br /><br />
+			but cannot simulate shiny surfaces with specular highlights (such as varnished wood). [name] uses per-fragment shading.<br /><br />
 
 			Due to the simplicity of the reflectance and illumination models, performance will be greater
 			when using this material over the [page:MeshPhongMaterial],	[page:MeshStandardMaterial] or [page:MeshPhysicalMaterial],

docs/api/en/materials/MeshPhongMaterial.html

@@ -16,7 +16,7 @@
 
 			The material uses a non-physically based [link:https://en.wikipedia.org/wiki/Blinn-Phong_shading_model Blinn-Phong]
 			model for calculating reflectance. Unlike the Lambertian model used in the [page:MeshLambertMaterial]
-			this can simulate shiny surfaces with specular highlights (such as varnished wood). [name] uses per-fragmet shading.<br /><br />
+			this can simulate shiny surfaces with specular highlights (such as varnished wood). [name] uses per-fragment shading.<br /><br />
 
 			Performance will generally be greater when using this material over the	[page:MeshStandardMaterial]
 			or [page:MeshPhysicalMaterial], at the cost of some graphical accuracy.

docs/api/en/materials/MeshPhysicalMaterial.html

@@ -29,6 +29,9 @@
 			<li>
 				<b>Advanced reflectivity:</b> More flexible reflectivity for non-metallic materials.
 			</li>
+			<li>
+				<b>Sheen:</b> Can be used for representing cloth and fabric materials.
+			</li>
 		</ul>
 
 		<p>
@@ -61,6 +64,7 @@
 			[example:webgl_materials_variations_physical materials / variations / physical]<br />
 			[example:webgl_materials_physical_clearcoat materials / physical / clearcoat]<br />
 			[example:webgl_materials_physical_reflectivity materials / physical / reflectivity]<br />
+			[example:webgl_loader_gltf_sheen loader / gltf / sheen]<br />
 			[example:webgl_materials_physical_transmission materials / physical / transmission]
 		</p>
 

docs/api/en/materials/MeshStandardMaterial.html

@@ -25,7 +25,7 @@
 			will react 'correctly' under all lighting scenarios.<br /><br />
 
 			In practice this gives a more accurate and realistic looking result than the [page:MeshLambertMaterial]
-			or [page:MeshPhongMaterial], at the cost of being somewhat more computationally expensive. [name] uses per-fragmet shading.<br /><br />
+			or [page:MeshPhongMaterial], at the cost of being somewhat more computationally expensive. [name] uses per-fragment shading.<br /><br />
 
 			Note that for best results you should always specify an [page:.envMap environment map] when using
 			this material.<br /><br />

docs/api/en/math/Interpolant.html

@@ -24,10 +24,6 @@
 		References:	[link:http://www.oodesign.com/template-method-pattern.html http://www.oodesign.com/template-method-pattern.html]
 		</p>
 
-
-		<h2>Constructor</h2>
-
-
 		<h2>Constructor</h2>
 
 		<h3>[name]( parameterPositions, sampleValues, sampleSize, resultBuffer )</h3>

docs/api/en/math/Triangle.html

@@ -118,7 +118,7 @@
 		[page:Vector3 point] - The point on the triangle.<br />
 		[page:Vector2 uv1] - The uv coordinate of the triangle's first vertex.<br />
 		[page:Vector2 uv2] - The uv coordinate of the triangle's second vertex.<br />
-		[page:Vector2 uv2] - The uv coordinate of the triangle's third vertex.<br />
+		[page:Vector2 uv3] - The uv coordinate of the triangle's third vertex.<br />
 		[page:Vector2 target] — the result will be copied into this Vector2.<br /><br />
 
 		Returns the uv coordinates for the given point on the triangle.

docs/api/en/objects/LOD.html

@@ -105,7 +105,7 @@
 		Get a reference to the first [page:Object3D] (mesh) that is greater than [page:Float distance].
 		</p>
 
-		<h3>[method:Array raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
+		<h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
 		<p>
 		Get intersections between a casted [page:Ray] and this LOD.
 		[page:Raycaster.intersectObject] will call this method.

docs/api/en/renderers/WebGL3DRenderTarget.html

@@ -19,9 +19,9 @@
 
 		<h3>[name]( [param:Number width], [param:Number height], [param:Number depth] )</h3>
 		<p>
-		[page:Number width] - the width of the render target, in pixels.<br />
-		[page:Number height] - the height of the render target, in pixels.<br />
-		[page:Number depth] - the depth of the render target.<br /><br />
+		[page:Number width] - the width of the render target, in pixels. Default is `1`.<br />
+		[page:Number height] - the height of the render target, in pixels. Default is `1`.<br />
+		[page:Number depth] - the depth of the render target. Default is `1`.<br /><br />
 
 		Creates a new [name].
 		</p>

docs/api/en/renderers/WebGLArrayRenderTarget.html

@@ -25,9 +25,9 @@
 
 		<h3>[name]( [param:Number width], [param:Number height], [param:Number depth] )</h3>
 		<p>
-		[page:Number width] - the width of the render target, in pixels.<br />
-		[page:Number height] - the height of the render target, in pixels.<br />
-		[page:Number depth] - the depth/layer count of the render target.<br /><br />
+		[page:Number width] - the width of the render target, in pixels. Default is `1`.<br />
+		[page:Number height] - the height of the render target, in pixels. Default is `1`.<br />
+		[page:Number depth] - the depth/layer count of the render target. Default is `1`.<br /><br />
 
 		Creates a new [name].
 		</p>

docs/api/en/renderers/WebGLCubeRenderTarget.html

@@ -25,7 +25,7 @@
 
 		<h3>[name]([param:Number size], [param:Object options])</h3>
 		<p>
-		[page:Float size] - the size, in pixels. <br />
+		[page:Float size] - the size, in pixels. Default is `1`.<br />
 		options - (optional) object that holds texture parameters for an auto-generated target
 		texture and depthBuffer/stencilBuffer booleans.
 

docs/api/en/renderers/WebGLMultipleRenderTargets.html

@@ -30,9 +30,9 @@
 		<h3>[name]([param:Number width], [param:Number height], [param:Number count], [param:Object options])</h3>
 
 		<p>
-		[page:Number width] - The width of the render target. <br />
-		[page:Number height] - The height of the render target.<br />
-		[page:Number count] - The number of render targets.<br />
+		[page:Number width] - The width of the render target. Default is `1`.<br />
+		[page:Number height] - The height of the render target. Default is `1`.<br />
+		[page:Number count] - The number of render targets. Default is `1`.<br />
 
 		options - (optional object that holds texture parameters for an auto-generated target
 		texture and depthBuffer/stencilBuffer booleans.

docs/api/en/renderers/WebGLRenderTarget.html

@@ -23,8 +23,8 @@
 		<h3>[name]([param:Number width], [param:Number height], [param:Object options])</h3>
 
 		<p>
-		[page:Float width] - The width of the renderTarget. <br />
-		[page:Float height] - The height of the renderTarget.<br />
+		[page:Float width] - The width of the renderTarget. Default is `1`.<br />
+		[page:Float height] - The height of the renderTarget. Default is `1`.<br />
 		options - optional object that holds texture parameters for an auto-generated target
 		texture and depthBuffer/stencilBuffer booleans.
 

docs/api/en/scenes/Scene.html

@@ -26,19 +26,29 @@
 
 		<h3>[property:Object background]</h3>
 		<p>
-		If not null, sets the background used when rendering the scene, and is always rendered first.
-		Can be set to a [page:Color] which sets the clear color, a [page:Texture] covering the canvas, a cubemap as a [page:CubeTexture] or an equirectangular as a [page:Texture] . Default is null.
+			Defines the background of the scene. Default is `null`. Valid inputs are:
+			<ul>
+				<li>A [page:Color] for defining a uniform colored background.</li>
+				<li>A [page:Texture] for defining a (flat) textured background.</li>
+				<li>Texture cubes ([page:CubeTexture]) or equirectangular textures for defining a skybox.</li>
+			</ul>
+			Note: Any camera related configurations like `zoom` or `view` are ignored.
+		</p>
+
+		<h3>[property:Float backgroundBlurriness]</h3>
+		<p>
+			Sets the blurriness of the background. Only influences environment maps assigned to [page:Scene.background]. Valid input is a float between *0* and *1*. Default is *0*.
 		</p>
 
 		<h3>[property:Texture environment]</h3>
 		<p>
-		If not null, this texture is set as the environment map for all physical materials in the scene.
-		However, it's not possible to overwrite an existing texture assigned to [page:MeshStandardMaterial.envMap]. Default is null.
+		Sets the environment map for all physical materials in the scene.
+		However, it's not possible to overwrite an existing texture assigned to [page:MeshStandardMaterial.envMap]. Default is `null`.
 		</p>
 
 		<h3>[property:Fog fog]</h3>
 
-		<p>A [page:Fog fog] instance defining the type of fog that affects everything rendered in the scene. Default is null.</p>
+		<p>A [page:Fog fog] instance defining the type of fog that affects everything rendered in the scene. Default is `null`.</p>
 
 		<h3>[property:Boolean isScene]</h3>
 		<p>
@@ -47,7 +57,7 @@
 
 		<h3>[property:Material overrideMaterial]</h3>
 
-		<p>If not null, it will force everything in the scene to be rendered with that material. Default is null.</p>
+		<p>Forces everything in the scene to be rendered with the defined material. Default is `null`.</p>
 
 		<h2>Methods</h2>
 

docs/api/en/textures/CompressedArrayTexture.html

@@ -0,0 +1,75 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:CompressedTexture] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+		Creates an texture 2D array based on data in compressed form, for example from a [link:https://en.wikipedia.org/wiki/DirectDraw_Surface DDS] file.<br /><br />
+
+
+		For use with the [page:CompressedTextureLoader CompressedTextureLoader].
+		</p>
+
+
+		<h2>Constructor</h2>
+
+
+		<h3>[name]( [param:Array mipmaps], [param:Number width], [param:Number height], [param:Constant format], [param:Constant type] )</h3>
+		<p>
+		[page:Array mipmaps] -- The mipmaps array should contain objects with data, width and height. The mipmaps should be of the correct format and type.<br />
+
+		[page:Number width] -- The width of the biggest mipmap.<br />
+
+		[page:Number height] -- The height of the biggest mipmap.<br />
+
+		[page:Number depth] -- The number of layers of the 2D array texture.<br />
+
+		[page:Constant format] -- The format used in the mipmaps.
+		See [page:Textures ST3C Compressed Texture Formats],
+		[page:Textures PVRTC Compressed Texture Formats] and
+		[page:Textures ETC Compressed Texture Format] for other choices.<br />
+
+		[page:Constant type] -- Default is [page:Textures THREE.UnsignedByteType].
+		See [page:Textures type constants] for other choices.<br />
+
+		</p>
+
+
+		<h2>Properties</h2>
+
+		See the base [page:CompressedTexture CompressedTexture] class for common properties.
+
+		<h3>[property:number wrapR]</h3>
+		<p>
+		This defines how the texture is wrapped in the depth direction.<br />
+		The default is [page:Textures THREE.ClampToEdgeWrapping], where the edge is clamped to the outer edge texels.
+		The other two choices are [page:Textures THREE.RepeatWrapping] and [page:Textures THREE.MirroredRepeatWrapping].
+		See the [page:Textures texture constants] page for details.
+		</p>
+
+		<h3>[property:Boolean isCompressedArrayTexture]</h3>
+		<p>
+			Read-only flag to check if a given object is of type [name].
+		</p>
+
+		<h2>Methods</h2>
+
+		<p>
+		See the base [page:CompressedTexture CompressedTexture] class for common methods.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/en/textures/VideoTexture.html

@@ -12,9 +12,11 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-		Creates a texture for use with a video texture.<br /><br />
+		Creates a texture for use with a video.
+		</p>
 
-		This is almost the same as the base [page:Texture Texture] class, except that it continuously sets [page:Texture.needsUpdate needsUpdate] to `true` so that the texture is updated as the video plays. Automatic creation of [page:Texture.mipmaps mipmaps] is also disabled.
+		<p>
+			Note: After the initial use of a texture, the video cannot be changed. Instead, call [page:.dispose]() on the texture and instantiate a new one.
 		</p>
 
 		<h2>Code Example</h2>
@@ -27,7 +29,13 @@
 
 		<h2>Examples</h2>
 
-		<p>[example:webgl_materials_video materials / video ]</p>
+		<p>
+			[example:webgl_materials_video materials / video]<br />
+			[example:webgl_materials_video_webcam materials / video / webcam]<br />
+			[example:webgl_video_kinect video / kinect]<br />
+			[example:webgl_video_panorama_equirectangular video / panorama / equirectangular]<br />
+			[example:webxr_vr_video vr / video]
+		</p>
 
 		<h2>Constructor</h2>
 		<h3>[name]( [param:Video video], [param:Constant mapping], [param:Constant wrapS], [param:Constant wrapT], [param:Constant magFilter], [param:Constant minFilter], [param:Constant format], [param:Constant type], [param:Number anisotropy] )</h3>
@@ -47,7 +55,7 @@
 		The default is [page:Textures THREE.LinearFilter]. See [page:Textures magnification filter constants] for other choices.<br />
 
 		[page:Constant minFilter] -- How the texture is sampled when a texel covers less than one pixel.
-		The default is [page:Textures THREE.LinearMipmapLinearFilter]. See [page:Textures minification filter constants] for other choices.<br />
+		The default is [page:Textures THREE.LinearFilter]. See [page:Textures minification filter constants] for other choices.<br />
 
 		[page:Constant format] -- The default is [page:Textures THREE.RGBAFormat].
 		See [page:Textures format constants] for other choices.<br />
@@ -69,7 +77,7 @@
 
 		<h3>[property:Boolean generateMipmaps]</h3>
 		<p>
-		Whether to generate mipmaps. False by default.
+		Whether to generate mipmaps. `false` by default.
 		</p>
 
 		<h3>[property:Boolean isVideoTexture]</h3>
@@ -79,7 +87,7 @@
 
 		<h3>[property:Boolean needsUpdate]</h3>
 		<p>
-		You will not need to set this manually here as it is handled by the [page:VideoTexture.update update] method.
+		You will not need to set this manually here as it is handled by the [page:VideoTexture.update update]() method.
 		</p>
 
 		<h2>Methods</h2>

docs/api/fr/core/BufferAttribute.html

@@ -0,0 +1,210 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+		Cette classe stocke les données d'un attribut (telles que les positions des sommets, les indices de face, les normales,
+		couleurs, UV et tout attribut personnalisé) associé à une [page:BufferGeometry], qui permet
+		une transmission plus efficace des données au GPU. Voir cette page pour plus de détails et un exemple d'utilisation.
+		Lorsque vous travaillez avec des données de type vecteur, les méthodes d'assistance <i>.fromBufferAttribute( attribute, index )</i>
+		des classes [page:Vector2.fromBufferAttribute Vector2],
+		[page:Vector3.fromBufferAttribute Vector3],
+		[page:Vector4.fromBufferAttribute Vector4], et
+		[page:Color.fromBufferAttribute Color] peuvent être utiles.
+		</p>
+
+		<h2>Constructeur</h2>
+		<h3>[name]( [param:TypedArray array], [param:Integer itemSize], [param:Boolean normalized] )</h3>
+		<p>
+		[page:TypedArray array] -- Doit être un [link:https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/TypedArray TypedArray].
+		Utilisé pour instancier un tampon (buffer). <br />
+		Ce tableau devrait avoir
+	 	<code>itemSize * numVertices</code>
+		éléments, où numVertices est le nombre de sommets dans le [page:BufferGeometry BufferGeometry].<br /><br />
+		[page:Integer itemSize] -- Le nombre de valeurs du tableau qui doivent être associées à
+		un sommet particulier. Par exemple, si l'attribut stocke un vecteur à 3 composants (tel qu'une position, une normale ou une couleur), alors itemSize doit être 3.
+		<br /><br />
+
+		[page:Boolean normalized] -- (optionnel) S'applique uniquement aux données entières. Indique comment les données sous-jacentes
+		dans le tampon correspond aux valeurs du code GLSL. Par exemple, si [page:TypedArray array] est une instance de
+		UInt16Array, et [page:Boolean normalized] est `true`, les valeurs `0 - +65535` dans le tableau
+		de données seront mappées à 0.0f - +1.0f dans l'attribut GLSL. Un Int16Array (signé) mapperait
+		de -32768 - +32767 à -1.0f - +1.0f. Si [page:Boolean normalized]  est faux, les valeurs
+		sera converti en flottants non modifiés, c'est-à-dire que 32767 devient 32767.0f.
+		</p>
+
+		<h2>Propriétés</h2>
+
+		<h3>[property:TypedArray array]</h3>
+		<p>
+		Le tableau [page:TypedArray array] contenant les données stockées dans le tampon.
+		</p>
+
+		<h3>[property:Integer count]</h3>
+		<p>
+		Stocke la longueur du tableau [page:BufferAttribute.array array] divisée par [page:BufferAttribute.itemSize itemSize].<br /><br />
+
+		Si le tampon stocke un vecteur à 3 composants (tel qu'une position, une normale ou une couleur),
+		cela comptera alors le nombre de ces vecteurs stockés.
+		</p>
+
+		<h3>[property:Boolean isBufferAttribute]</h3>
+		<p>
+		Booléen en lecture seule pour vérifier si un objet donné est de type[name].
+		</p>
+
+		<h3>[property:Integer itemSize]</h3>
+		<p>La longueur des vecteurs qui sont stockés dans le [page:BufferAttribute.array array].</p>
+
+		<h3>[property:String name]</h3>
+		<p>
+		Nom optionnel pour cette instance d'attribut. La valeur par défaut est une chaîne vide.
+		</p>
+
+		<h3>[property:Boolean needsUpdate]</h3>
+		<p>
+		Booléen indiquant que cet attribut a changé et doit être renvoyé au GPU.
+		Définissez-le sur true lorsque vous modifiez la valeur du tableau.<br /><br />
+
+		Le définir sur 'true' revient à incrémenter la [page:BufferAttribute.version version].
+		</p>
+
+		<h3>[property:Boolean normalized]</h3>
+		<p>
+		Indique comment les données sous-jacentes dans la mémoire tampon sont mappées aux valeurs du code de nuanceur GLSL.
+		Voir le constructeur ci-dessus pour plus de détails.
+		</p>
+
+		<h3>[property:Function onUploadCallback]</h3>
+		<p>
+		Une fonction de rappel qui est exécutée après que le Renderer a transféré les données du tableau d'attributs au GPU.
+		</p>
+
+		<h3>[property:Object updateRange]</h3>
+		<p>Object contenant:<br />
+			[page:Integer offset]: La valeur par défaut est `0`. Position à laquelle commencer la mise à jour.<br />
+			[page:Integer count]: La valeur par défaut est `-1`, ce qui signifie ne pas utiliser les plages de mise à jour. <br /><br />
+
+			Cela peut être utilisé pour mettre à jour uniquement certains composants de vecteurs stockés (par exemple, seul le composant
+			lié à la couleur).
+		</p>
+
+		<h3>[property:Usage usage]</h3>
+		<p>
+			Définit le modèle d'utilisation prévu du magasin de données à des fins d'optimisation. Correspond au paramètre `usage` de
+			[link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/bufferData WebGLRenderingContext.bufferData]().
+			La valeur par défaut est [page:BufferAttributeUsage StaticDrawUsage]. Voir les [page:BufferAttributeUsage constants] d'utilisation pour toutes les valeurs possibles. <br /><br />
+			
+			Remarque : Après la première utilisation d'un tampon, son utilisation ne peut pas être modifiée. Au lieu de cela, instanciez-en un nouveau et définissez l'utilisation souhaitée avant le prochain rendu.
+		</p>
+
+		<h3>[property:Integer version]</h3>
+		<p>Un numéro de version incrémenté à chaque fois que la propriété [page:BufferAttribute.needsUpdate needsUpdate] est définie sur `true`.</p>
+
+		<h2>Méthodes</h2>
+
+		<h3>[method:this applyMatrix3]( [param:Matrix3 m] )</h3>
+		<p>Applique la matrice [page:Matrix3 m] à chaque élément Vector3 de ce BufferAttribute.</p>
+
+		<h3>[method:this applyMatrix4]( [param:Matrix4 m] )</h3>
+		<p>Applique la matrice [page:Matrix4 m] à chaque élément Vector3 de ce BufferAttribute.</p>
+
+		<h3>[method:this applyNormalMatrix]( [param:Matrix3 m] )</h3>
+		<p>Applique la matrice de normales [page:Matrix3 m] à chaque élément Vector3 de ce BufferAttribute.</p>
+
+		<h3>[method:this transformDirection]( [param:Matrix4 m] )</h3>
+		<p>Applique la matrice [page:Matrix4 m] à chaque élément Vector3 de ce BufferAttribute, en interprétant les éléments comme des vecteurs directionnels.</p>
+
+		<h3>[method:BufferAttribute clone]() </h3>
+		<p>Renvoie une copie de ce bufferAttribute.</p>
+
+		<h3>[method:this copy]( [param:BufferAttribute bufferAttribute] )</h3>
+		<p>Copie un autre BufferAttribute à ce BufferAttribute.</p>
+
+		<h3>[method:this copyArray]( array ) </h3>
+		<p>Copie le tableau donné ici (qui peut être un tableau classique ou un TypedArray) vers un
+			[page:BufferAttribute.array array].<br /><br />
+
+			Consulter [link:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set TypedArray.set]
+			pour lire les exigences en cas de copie d'un TypedArray.
+		</p>
+
+		<h3>[method:this copyAt] ( [param:Integer index1], [param:BufferAttribute bufferAttribute], [param:Integer index2] ) </h3>
+		<p>Copie un vecteur de bufferAttribute[index2] à [page:BufferAttribute.array array][index1].</p>
+
+		<h3>[method:Number getX]( [param:Integer index] ) </h3>
+		<p>Renvoie le composant x d'un vecteur à l'index donné.</p>
+
+		<h3>[method:Number getY]( [param:Integer index] ) </h3>
+		<p>Renvoie le composant y d'un vecteur à l'index donné.</p>
+
+		<h3>[method:Number getZ]( [param:Integer index] ) </h3>
+		<p>Renvoie le composant z d'un vecteur à l'index donné.</p>
+
+		<h3>[method:Number getW]( [param:Integer index] ) </h3>
+		<p>Renvoie le composant w d'un vecteur à l'index donné.</p>
+
+		<h3>[method:this onUpload]( [param:Function callback] ) </h3>
+		<p>
+		Définit la valeur d'une propriété onUploadCallback.<br /><br />
+
+		Dans l'exemple [example:webgl_buffergeometry WebGL / Buffergeometry] ceci est utilisé pour libérer de la mémoire
+		après le transfert du tampon vers le GPU.
+		</p>
+
+		<h3>[method:this set] ( [param:Array value], [param:Integer offset] ) </h3>
+		<p>
+		value -- un [page:Array] ou [page:TypedArray] depuis lequel copier les valeurs <br />
+		offset -- (optionnel) index du [page:BufferAttribute.array array] depuis lequel commencer la copie.<br /><br />
+
+		Appelle	[link:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set TypedArray.set]( [page:Array value], [page:Integer offset] )
+		sur le [page:BufferAttribute.array array].<br /><br />
+
+		En particulier, consultez cette page pour les exigences relatives à la valeur [page:Array value]
+		en tant que [page:TypedArray].
+		</p>
+
+		<h3>[method:this setUsage] ( [param:Usage value] ) </h3>
+		<p>
+			Définit [page:BufferAttribute.usage usage] sur la valeur. Voir les [page:BufferAttributeUsage constants] pour toutes les valeurs d'entrée possibles.  <br /><br />
+
+			Remarque : Après la première utilisation d'un tampon, son utilisation ne peut pas être modifiée. Au lieu de cela, instanciez-en un nouveau et définissez l'utilisation souhaitée avant le prochain rendu.
+		</p>
+
+		<h3>[method:this setX]( [param:Integer index], [param:Float x] ) </h3>
+		<p>Définit la composante x du vecteur à l'indice donné.</p>
+
+		<h3>[method:this setY]( [param:Integer index], [param:Float y] ) </h3>
+		<p>Définit la composante y du vecteur à l'indice donné.</p>
+
+		<h3>[method:this setZ]( [param:Integer index], [param:Float z] ) </h3>
+		<p>Définit la composante z du vecteur à l'indice donné.</p>
+
+		<h3>[method:this setW]( [param:Integer index], [param:Float w] ) </h3>
+		<p>Définit la composante w du vecteur à l'indice donné.</p>
+
+		<h3>[method:this setXY]( [param:Integer index], [param:Float x], [param:Float y] ) </h3>
+		<p>Définit les composantes x et y du vecteur à l'indice donné.</p>
+
+		<h3>[method:this setXYZ]( [param:Integer index], [param:Float x], [param:Float y], [param:Float z] ) </h3>
+		<p>Définit les composantes x, y et z du vecteur à l'indice donné.</p>
+
+		<h3>[method:this setXYZW]( [param:Integer index], [param:Float x], [param:Float y], [param:Float z], [param:Float w] ) </h3>
+		<p>Définit les composantes x, y, z et w du vecteur à l'indice donné.</p>
+
+
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/core/BufferGeometry.html

@@ -0,0 +1,309 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p>
+		Représentation d'une géométrie de maillage, de ligne ou de point. Comprend les positions des sommets, les indices de faces,
+		normales, couleurs, UV et attributs personnalisés dans les tampons, réduisant ainsi le coût de
+		transmettre toutes ces données au GPU.
+		</p>
+		<p>
+			Pour lire et modifier des données dans les attributs BufferGeometry, consultez la documentation [page:BufferAttribute].
+		</p>
+
+		<h2>Exemple de code : </h2>
+		<code>
+		const geometry = new THREE.BufferGeometry();
+		// créer une forme carrée simple. Nous dupliquons le haut à gauche et le bas à droite
+		// sommets car chaque sommet doit apparaître une fois par triangle.
+		const vertices = new Float32Array( [
+			-1.0, -1.0,  1.0,
+			 1.0, -1.0,  1.0,
+			 1.0,  1.0,  1.0,
+
+			 1.0,  1.0,  1.0,
+			-1.0,  1.0,  1.0,
+			-1.0, -1.0,  1.0
+		] );
+
+		// itemSize = 3 parce qu'il y a 3 valeurs (comoosants) par sommet
+		geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+		const material = new THREE.MeshBasicMaterial( { color: 0xff0000 } );
+		const mesh = new THREE.Mesh( geometry, material );
+		</code>
+
+		<h2>Exemples</h2>
+		<p>
+			[example:webgl_buffergeometry Mesh with non-indexed faces]<br />
+			[example:webgl_buffergeometry_indexed Mesh with indexed faces]<br />
+			[example:webgl_buffergeometry_lines Lines]<br />
+			[example:webgl_buffergeometry_lines_indexed Indexed Lines]<br />
+			[example:webgl_buffergeometry_custom_attributes_particles Particles]<br />
+			[example:webgl_buffergeometry_rawshader Raw Shaders]
+		</p>
+
+		<h2>Constructeur</h2>
+
+
+		<h3>[name]()</h3>
+		<div>
+		Cela crée un nouveau [name]. Il définit également plusieurs propriétés sur une valeur par défaut.
+		</div>
+
+
+		<h2>Propriétés</h2>
+
+		<h3>[property:Object attributes]</h3>
+		<p>
+		Ce hashmap a comme identifiant le nom de l'attribut à définir et comme valeur le [page:BufferAttribute buffer] à lui attribuer.
+		Plutôt que d'accéder directement à cette propriété, utilisez [page:.setAttribute] et [page:.getAttribute] pour accéder aux attributs de cette géométrie.
+		</p>
+
+		<h3>[property:Box3 boundingBox]</h3>
+		<p>
+			Boîte englobante pour le bufferGeometry, qui peut être calculée avec
+			[page:.computeBoundingBox](). La valeur par défaut est `null`.
+		</p>
+
+		<h3>[property:Sphere boundingSphere]</h3>
+		<p>
+			Sphère englobante pour le bufferGeometry, qui peut être calculée avec
+			[page:.computeBoundingSphere](). La valeur par défaut est `null`.
+		</p>
+
+		<h3>[property:Object drawRange]</h3>
+		<p>
+			Détermine la partie de la géométrie à rendre. Cela ne devrait pas
+			être défini directement, utilisez à la place[page:.setDrawRange]. La valeur par défaut est
+			<code>
+				{ start: 0, count: Infinity }
+			</code>
+			Pour BufferGeometry non indexé, count est le nombre de sommets à rendre.
+			Pour BufferGeometry indexé, count est le nombre d'indices à rendre.
+		</p>
+
+		<h3>[property:Array groups]</h3>
+		<p>
+			Divise la géométrie en groupes, dont chacun sera rendu dans un appel de dessin WebGL distinct.
+			Cela permet d'utiliser un éventail de matériaux avec la géométrie.<br /><br />
+
+			Chaque groupe est un objet de la forme :
+			<code>{ start: Integer, count: Integer, materialIndex: Integer }</code>
+			où start spécifie le premier élément de cet appel de dessin - le premier sommet de la géométrie non indexée,
+			sinon le premier indice triangulaire. Count spécifie combien de sommets (ou indices) sont inclus, et
+			materialIndex spécifie l'index de tableau de matériaux à utiliser.<br /><br />
+
+			Utilisez [page:.addGroup] pour ajouter des groupes au lieu de modifier le tableau directement.<br /><br />
+
+			Chaque sommet et index doit appartenir à exactement un groupe — les groupes ne doivent pas partager de sommets ou d'indices, et ne doivent pas laisser de sommets ou d'indices inutilisés.
+		</p>
+
+
+		<!-- Note: groups used to be called drawCalls
+
+		<h3>[property:Array drawcalls]</h3>
+		<p>
+		For geometries that use indexed triangles, this Array can be used to split the object
+		into multiple WebGL draw calls. Each draw call will draw some subset of the vertices
+		in this geometry using the configured [page:Material shader]. This may be necessary if,
+		for instance, you have more than 65535 vertices in your object.
+		</p> -->
+
+
+		<h3>[property:Integer id]</h3>
+		<p>Numéro unique pour cette instance de bufferGeometry.</p>
+
+		<h3>[property:BufferAttribute index]</h3>
+		<p>
+			Permet de réutiliser les sommets sur plusieurs triangles ; c'est ce qu'on appelle utiliser des "triangles indexés".
+			Chaque triangle est associé aux indices de trois sommets. Cet attribut stocke donc l'indice de chaque sommet pour chaque face triangulaire.
+
+			Si cet attribut n'est pas défini, le [page: WebGLRenderer renderer] suppose que chacun des trois éléments contigus
+			les positions représentent un seul triangle.
+
+			La valeur par défaut est `null`.
+		</p>
+
+		<h3>[property:Boolean isBufferGeometry]</h3>
+		<p>
+			Booléen en lecture seule pour vérifier si un objet donné est de type [name].
+		</p>
+
+		<h3>[property:Object morphAttributes]</h3>
+		<p>
+			Hashmap de [page:BufferAttribute] contenant les détails des cibles de morphing de la géométrie.<br />
+			Remarque : Une fois la géométrie rendue, les données d'attribut de morphing ne peuvent pas être modifiées. Vous devrez appeler [page:.dispose]() et créer une nouvelle instance de [nom].
+		</p>
+
+		<h3>[property:Boolean morphTargetsRelative]</h3>
+		<p>
+			Utilisé pour contrôler le comportement de la cible de morphing ; lorsqu'il est défini sur true, les données cibles de morphing sont traitées comme des décalages relatifs, plutôt que comme des positions/normales absolues.
+
+			La valeur par défaut est "faux".
+		</p>
+
+		<h3>[property:String name]</h3>
+		<p>
+			Nom facultatif pour cette instance de bufferGeometry. La valeur par défaut est une chaîne vide.
+		</p>
+
+		<h3>[property:Object userData]</h3>
+		<p>
+			Un objet qui peut être utilisé pour stocker des données personnalisées sur le BufferGeometry. Il ne doit pas contenir
+			de références aux fonctions car celles-ci ne seront pas clonées.
+		</p>
+
+		<h3>[property:String uuid]</h3>
+		<p>
+		[link:http://en.wikipedia.org/wiki/Universally_unique_identifier UUID] de l'instance de l'objet.
+		Celui-ci est automatiquement attribué et ne doit pas être modifié.
+		</p>
+
+		<h2>Méthodes</h2>
+
+		<p>Les méthodes [page:EventDispatcher EventDispatcher] sont accessibles depuis cette classe.</p>
+
+		<h3>[method:undefined addGroup]( [param:Integer start], [param:Integer count], [param:Integer materialIndex] )</h3>
+		<p>
+			Ajoute un groupe à cette géométrie; voir les propriétés des [page:BufferGeometry.groups groups]
+			pour plus de détails.
+		</p>
+
+		<h3>[method:this applyMatrix4]( [param:Matrix4 matrix] )</h3>
+		<p>Applique la transformation matricielle à la géométrie.</p>
+
+		<h3>[method:this applyQuaternion]( [param:Quaternion quaternion] )</h3>
+		<p>Applique la rotation représentée par le quaternion à la géométrie.</p>
+
+		<h3>[method:this center] ()</h3>
+		<p>Centre la géométrie en fonction de la boîte englobante.</p>
+
+		<h3>[method:undefined clearGroups]( )</h3>
+		<p>Efface tous les groupes.</p>
+
+		<h3>[method:BufferGeometry clone]()</h3>
+		<p>Crée un clone de ce BufferGeometry.</p>
+
+		<h3>[method:undefined computeBoundingBox]()</h3>
+		<p>
+		Calcule la boîte englobante de la géométrie, met à jour l'attribut [page:.boundingBox].<br />
+		Les boîtes englobantes ne sont pas calculées par défaut. Ils doivent être calculés explicitement, sinon elles sont `null`.
+		</p>
+
+		<h3>[method:undefined computeBoundingSphere]()</h3>
+		<p>
+		Calcule la boîte englobante de la géométrie, met à jour l'attribut [page:.boundingSphere].<br />
+		Les sphères englobantes ne sont pas calculées par défaut. Ils doivent être calculés explicitement, sinon elles sont `null`.
+		</p>
+
+		<h3>[method:undefined computeTangents]()</h3>
+		<p>
+		Calcule et ajoute un attribut de tangente à cette géométrie.<br />
+		Le calcul n'est pris en charge que pour les géométries indexées et si les attributs position, normal et uv sont définis. Lorsque vous utilisez une carte normale d'espace tangent, favorisez l'algorithme MikkTSpace fourni par
+		[page:BufferGeometryUtils.computeMikkTSpaceTangents].
+		</p>
+
+		<h3>[method:undefined computeVertexNormals]()</h3>
+		<p>Calcule les normales des sommets en faisant la moyenne des normales des faces.</p>
+
+		<h3>[method:this copy]( [param:BufferGeometry bufferGeometry] )</h3>
+		<p>Copie un autre BufferGeometry dans ce BufferGeometry.</p>
+
+		<h3>[method:BufferAttribute deleteAttribute]( [param:String name] )</h3>
+		<p>Efface un [page:BufferAttribute attribute] avec le nom spécifié.</p>
+
+		<h3>[method:undefined dispose]()</h3>
+		<p>
+		Libère les ressources liées au GPU allouées par cette instance. Appelez cette méthode chaque fois que cette instance n'est plus utilisée dans votre application.
+		</p>
+
+		<h3>[method:BufferAttribute getAttribute]( [param:String name] )</h3>
+		<p>Renvoie un [page:BufferAttribute attribute] avec le nom spécifié.</p>
+
+		<h3>[method:BufferAttribute getIndex] ()</h3>
+		<p>Retourne le tampon [page:.index].</p>
+
+		<h3>[method:Boolean hasAttribute]( [param:String name] )</h3>
+		<p>Renvoie `true` si l'attribut avec le nom spécifié existe.</p>
+
+		<h3>[method:this lookAt] ( [param:Vector3 vector] )</h3>
+		<p>
+		vector - Un vecteur monde à regarder.<br /><br />
+
+		Fait pivoter la géométrie pour faire face à un point dans l'espace. Cela se fait généralement en une seule opération et non pendant une boucle.
+		Utilisez [page:Object3D.lookAt] pour une utilisation typique du maillage en temps réel.
+		</p>
+
+		<h3>[method:undefined normalizeNormals]()</h3>
+		<p>
+		Chaque vecteur normal dans une géométrie aura une magnitude de 1.
+		Cela corrigera l'éclairage sur les surfaces géométriques.
+		</p>
+
+		<h3>[method:this rotateX] ( [param:Float radians] )</h3>
+		<p>
+		Fait pivoter la géométrie autour de l'axe X. Cela se fait généralement en une seule opération et non pendant une boucle.
+    Utilisez [page:Object3D.rotation] pour une utilisation typique du maillage en temps réel.
+		</p>
+
+		<h3>[method:this rotateY] ( [param:Float radians] )</h3>
+		<p>
+		Fait pivoter la géométrie autour de l'axe Y. Cela se fait généralement en une seule opération et non pendant une boucle.
+    Utilisez [page:Object3D.rotation] pour une utilisation typique du maillage en temps réel.
+		</p>
+
+		<h3>[method:this rotateZ] ( [param:Float radians] )</h3>
+		<p>
+		Fait pivoter la géométrie autour de l'axe Z. Cela se fait généralement en une seule opération et non pendant une boucle.
+    Utilisez [page:Object3D.rotation] pour une utilisation typique du maillage en temps réel.
+		</p>
+
+		<h3>[method:this scale] ( [param:Float x], [param:Float y], [param:Float z] )</h3>
+		<p>
+		Mettre à l'échelle les données géométriques. Cela se fait généralement en une seule opération et non pendant une boucle.	
+	Utilisez [page:Object3D.scale] pour une utilisation typique du maillage en temps réel.
+		</p>
+
+		<h3>[method:this setAttribute]( [param:String name], [param:BufferAttribute attribute] )</h3>
+		<p>
+		Définit un attribut pour cette géométrie. Utilisez ceci plutôt que la propriété attributs,
+		parce qu'un hashmap interne de [page:.attributes] est maintenu pour accélérer l'itération sur
+		les attributs.
+		</p>
+
+		<h3>[method:undefined setDrawRange] ( [param:Integer start], [param:Integer count] )</h3>
+		<p>Définissez la propriété [page:.drawRange]. Pour un BufferGeometry non indexé, count est le nombre de sommets à rendre.
+		Pour un BufferGeometry indexé, count est le nombre d'indices à rendre.</p>
+
+		<h3>[method:this setFromPoints] ( [param:Array points] )</h3>
+		<p>Définit les attributs de ce BufferGeometry à partir d'un tableau de points.</p>
+
+		<h3>[method:this setIndex] ( [param:BufferAttribute index] )</h3>
+		<p>Définit le buffer [page:.index].</p>
+
+		<h3>[method:Object toJSON]()</h3>
+		<p>Convertit la BufferGeometry en three.js [link:https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4 JSON Object/Scene format].</p>
+
+		<h3>[method:BufferGeometry toNonIndexed]()</h3>
+		<p>Renvoie une version non indexée d'une BufferGeometry indexée.</p>
+
+		<h3>[method:this translate] ( [param:Float x], [param:Float y], [param:Float z] )</h3>
+		<p>
+		Déplace la géométrie. Cela se fait généralement en une seule opération et non pendant une boucle.
+		Utilisez [page:Object3D.position] pour un déplacement de maillage en temps réel typique.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/BoxGeometry.html

@@ -0,0 +1,74 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			[name] est une classe de géométrie pour un cuboïde rectangulaire avec une largeur 'width', une hauteur 'height', et une profondeur 'depth' données.
+			À la création, le cuboïde est centré sur l'origine, chaque arrête est parallèle à l'un des axes. 
+		</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#BoxGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code : </h2>
+
+		<code>const geometry = new THREE.BoxGeometry( 1, 1, 1 );
+		const material = new THREE.MeshBasicMaterial( {color: 0x00ff00} );
+		const cube = new THREE.Mesh( geometry, material );
+		scene.add( cube );
+		</code>
+
+		<h2>Contructeur</h2>
+
+		<h3>[name]([param:Float width], [param:Float height], [param:Float depth], [param:Integer widthSegments], [param:Integer heightSegments], [param:Integer depthSegments])</h3>
+		<p>
+		width — Largeur; c'est-à-dire la longueur des arêtes parallèles à l'axe X. Optionnel; par défaut à 1.<br />
+		height — Hauteur; c'est-à-dire la longueur des arêtes parallèles à l'axe Y. Optionnel; par défaut à 1.<br />
+		depth — Profondeur; c'est-à-dire la longueur des arêtes parallèles à l'axe Z. Optionnel; par défaut à 1.<br />
+		widthSegments — Nombre de faces rectangulaires segmentées sur la largeur des côtés. Optionnel; par défaut à 1.<br />
+		heightSegments — Nombre de faces rectangulaires segmentées sur la hauteur des côtés. Optionnel; par défaut à 1.<br />
+		depthSegments — Nombre de faces rectangulaires segmentées le long de la profondeur des côtés. Optionnel; par défaut à 1.<br />
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Methods</h2>
+		<p>Voir la classe de base [page:BufferGeometry] Pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/CapsuleGeometry.html

@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr; [page:LatheGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			[name] est une classe de géométrie pour une capsule avec des rayons et une hauteur donnés.
+			Elle est construite à l'aide de demi-shpères.
+		</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#CapsuleGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code : </h2>
+
+		<code>const geometry = new THREE.CapsuleGeometry( 1, 1, 4, 8 );
+		const material = new THREE.MeshBasicMaterial( {color: 0x00ff00} );
+		const capsule = new THREE.Mesh( geometry, material );
+		scene.add( capsule );
+		</code>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float radius], [param:Float length], [param:Integer capSubdivisions], [param:Integer radialSegments])</h3>
+		<p>
+
+		radius — Rayon de la capsule. Optionnel; par défaut à 1.<br />
+		length — Longueur de la section médiane. Optionnel; par défaut à 1.<br />
+		capSegments — Nombre de segments de courbe utilisés pour construire les demi-sphères. Optionnel; par défaut à 4.<br />
+		radialSegments — Nombre de faces segmentées autour de la circonférence de la capsule. Optionnel; par défaut à 8.<br />
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/CircleGeometry.html

@@ -0,0 +1,75 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			[name] est une forme simple de la géométrie euclidienne.
+			Elle est construite à partir d'un certain nombre de segments triangulaires orientés autour d'un point central et s'étendant jusqu'à un rayon donné.
+			Elle est construite dans le sens inverse des aiguilles d'une montre à partir d'un angle de départ et d'un angle central donné.
+			Elle peut également être utilisée pour créer des polygones réguliers, où le nombre de segments détermine le nombre de côtés.
+		</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#CircleGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code : </h2>
+
+		<code>
+		const geometry = new THREE.CircleGeometry( 5, 32 );
+		const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+		const circle = new THREE.Mesh( geometry, material );
+		scene.add( circle );
+		</code>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float radius], [param:Integer segments], [param:Float thetaStart], [param:Float thetaLength])</h3>
+		<p>
+		radius — Rayon du cercle, par défaut = 1.<br />
+		segments — Nombre de segments (triangles), minimum = 3, défaut = 8.<br />
+		thetaStart — Angle de départ pour le premier segment, par défaut = 0 (position trois heures).<br />
+		thetaLength — L'angle central, souvent appelé thêta, du secteur circulaire. La valeur par défaut est 2*Pi, ce qui fait un cercle complet.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/ConeGeometry.html

@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr; [page:CylinderGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Une classe pour générer des géométries de cône.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#ConeGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code :</h2>
+
+		<code>const geometry = new THREE.ConeGeometry( 5, 20, 32 );
+		const material = new THREE.MeshBasicMaterial( {color: 0xffff00} );
+		const cone = new THREE.Mesh( geometry, material );
+		scene.add( cone );
+		</code>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float radius], [param:Float height], [param:Integer radialSegments], [param:Integer heightSegments], [param:Boolean openEnded], [param:Float thetaStart], [param:Float thetaLength])</h3>
+		<p>
+		radius — Rayon de la base du cône. La valeur par défaut est 1.<br />
+		height — Hauteur du cône. La valeur par défaut est 1.<br />
+		radialSegments — Nombre de faces segmentées autour de la circonférence du cône. La valeur par défaut est 8.<br />
+		heightSegments — Nombre de rangées de faces sur la hauteur du cône. La valeur par défaut est 1.<br />
+		openEnded — Un booléen indiquant si la base du cône est ouverte ou fermée. La valeur par défaut est false, ce qui signifie fermée.<br />
+		thetaStart — Angle de départ pour le premier segment, par défaut = 0 (position trois heures).<br />
+		thetaLength — L'angle central, souvent appelé thêta, du secteur circulaire. La valeur par défaut est 2*Pi, ce qui donne un cône complet. 
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:CylinderGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:CylinderGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/CylinderGeometry.html

@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Une classe pour générer des géométries de cylindre.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#CylinderGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code : </h2>
+
+		<code>const geometry = new THREE.CylinderGeometry( 5, 5, 20, 32 );
+		const material = new THREE.MeshBasicMaterial( {color: 0xffff00} );
+		const cylinder = new THREE.Mesh( geometry, material );
+		scene.add( cylinder );
+		</code>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float radiusTop], [param:Float radiusBottom], [param:Float height], [param:Integer radialSegments], [param:Integer heightSegments], [param:Boolean openEnded], [param:Float thetaStart], [param:Float thetaLength])</h3>
+		<p>
+		radiusTop — Rayon du cylindre supérieur. La valeur par défaut est 1.<br />
+		radiusBottom — Rayon du cylindre inférieur. La valeur par défaut est 1.<br />
+		height — Hauteur du cylindre. La valeur par défaut est 1.<br />
+		radialSegments — Nombre de faces segmentées autour de la circonférence du cylindre. La valeur par défaut est 8.<br />
+		heightSegments — Nombre de rangées de faces sur la hauteur du cylindre. La valeur par défaut est 1.<br />
+		openEnded — Un booléen indiquant si les extrémités du cylindre sont ouvertes ou fermées. La valeur par défaut est false, ce qui signifie fermées.<br />
+		thetaStart — Angle de départ pour le premier segment, par défaut = 0 (position trois heures).<br />
+		thetaLength — L'angle central, souvent appelé thêta, du secteur circulaire. La valeur par défaut est 2*Pi, ce qui donne un cylindre complet.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/DodecahedronGeometry.html

@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr; [page:PolyhedronGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Une classe pour générer des géométries de dodécaèdre.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#DodecahedronGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float radius], [param:Integer detail])</h3>
+		<p>
+		radius — Rayon du dodécaèdre. La valeur par défaut est 1.<br />
+		detail — La valeur par défaut est 0. Définir une valeur supérieure à 0 ajoute des sommets, la géométrie n'est donc plus un dodécaèdre.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:PolyhedronGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+			Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:PolyhedronGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/EdgesGeometry.html

@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Cela peut être utilisé comme objet d'assistance pour afficher les bords d'un [page:BufferGeometry geometry].</p>
+
+		<h2>Exemple de code : </h2>
+
+		<code>
+const geometry = new THREE.BoxGeometry( 100, 100, 100 );
+const edges = new THREE.EdgesGeometry( geometry );
+const line = new THREE.LineSegments( edges, new THREE.LineBasicMaterial( { color: 0xffffff } ) );
+scene.add( line );
+		</code>
+
+		<h2>Exemples</h2>
+		<p>
+			[example:webgl_helpers helpers]
+		</p>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]( [param:BufferGeometry geometry], [param:Integer thresholdAngle] )</h3>
+		<p>
+		geometry — Tout objet géométrique.<br />
+		thresholdAngle — Une arête n'est rendue que si l'angle (en degrés) entre les normales des faces adjacentes dépasse cette valeur. par défaut = 1 degré.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/ExtrudeGeometry.html

@@ -0,0 +1,113 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Crée une géométrie extrudée à partir d'une forme de chemin.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#ExtrudeGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code : </h2>
+
+
+		<code>
+		const length = 12, width = 8;
+
+		const shape = new THREE.Shape();
+		shape.moveTo( 0,0 );
+		shape.lineTo( 0, width );
+		shape.lineTo( length, width );
+		shape.lineTo( length, 0 );
+		shape.lineTo( 0, 0 );
+
+		const extrudeSettings = {
+			steps: 2,
+			depth: 16,
+			bevelEnabled: true,
+			bevelThickness: 1,
+			bevelSize: 1,
+			bevelOffset: 0,
+			bevelSegments: 1
+		};
+
+		const geometry = new THREE.ExtrudeGeometry( shape, extrudeSettings );
+		const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+		const mesh = new THREE.Mesh( geometry, material ) ;
+		scene.add( mesh );
+		</code>
+
+
+		<h2>Constructeur</h2>
+
+
+		<h3>[name]([param:Array shapes], [param:Object options])</h3>
+		<p>
+		shapes — Forme ou tableau de formes.<br />
+		options — Objet pouvant contenir les paramètres suivants.
+
+			<ul>
+				<li>curveSegments — int. Nombre de points sur les courbes. La valeur par défaut est 12.</li>
+				<li>steps — int. Nombre de points utilisés pour subdiviser les segments le long de la profondeur de la courbe extrudée. La valeur par défaut est 1.</li>
+				<li>depth — float. Profondeur pour extruder la forme. La valeur par défaut est 1.</li>
+				<li>bevelEnabled — bool. Appliquer un biseau à la forme. La valeur par défaut est true.</li>
+				<li>bevelThickness — float. Profondeur du biseau dans la forme d'origine. La valeur par défaut est 0,2.</li>
+				<li>bevelSize — float. Distance du contour de la forme à laquelle s'étend le biseau. La valeur par défaut est bevelThickness - 0.1.</li>
+				<li>bevelOffset — float. Distance du contour de la forme à laquelle commence le biseau. La valeur par défaut est 0.</li>
+				<li>bevelSegments — int. Nombre de couches de biseau. La valeur par défaut est 3.</li>
+				<li>extrudePath — THREE.Curve. Chemin de courbe 3D le long duquel la forme doit être extrudée. Biseaux non pris en charge pour l'extrusion de chemin.</li>
+				<li>UVGenerator —  Object. Objet qui fournit des fonctions de générateur d'UV</li>
+			</ul>
+
+		</p>
+		<p>
+			Cet objet extrude une forme 2D en une géométrie 3D.
+		</p>
+
+		<p>
+			Lors de la création d'un maillage avec cette géométrie, si vous souhaitez utiliser un matériau distinct pour sa face
+			et ses côtés extrudés, vous pouvez utiliser un éventail de matériaux. Le premier matériau sera
+			appliqué sur la face, le deuxième sera appliqué sur les côtés.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/IcosahedronGeometry.html

@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr; [page:PolyhedronGeometry] &rarr;
+		<h1>[name]</h1>
+
+		<p class="desc">Une classe pour générer une géométrie d'icosaèdre.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#IcosahedronGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float radius], [param:Integer detail])</h3>
+		<p>
+		radius — La valeur par défaut est 1. <br />
+		detail — La valeur par défaut est 0. Le définir sur une valeur supérieure à 0 ajoute plus de sommets, la géométrie n'est donc plus un icosaèdre. Lorsque le détail est supérieur à 1, la géométrie est une sphère.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:PolyhedronGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:PolyhedronGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/LatheGeometry.html

@@ -0,0 +1,77 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Crée des maillages à symétrie axiale comme des vases. Le tour tourne autour de l'axe Y.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#LatheGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code :</h2>
+
+		<code>
+		const points = [];
+		for ( let i = 0; i < 10; i ++ ) {
+			points.push( new THREE.Vector2( Math.sin( i * 0.2 ) * 10 + 5, ( i - 5 ) * 2 ) );
+		}
+		const geometry = new THREE.LatheGeometry( points );
+		const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+		const lathe = new THREE.Mesh( geometry, material );
+		scene.add( lathe );
+		</code>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Array points], [param:Integer segments], [param:Float phiStart], [param:Float phiLength])</h3>
+		<p>
+		points — Tableau de Vector2s. La coordonnée x de chaque point doit être supérieure à zéro. La valeur par défaut est un tableau avec (0,-0.5), (0.5,0) et (0,0.5) qui crée une forme de losange simple.<br />
+		segments — Le nombre de segments de circonférence à générer. La valeur par défaut est 12.<br />
+		phiStart — L'angle de départ en radians. La valeur par défaut est 0.<br />
+		phiLength — La plage de radian (0 à 2PI) de la section du vase. 2PI est un vase fermé, moins de 2PI en est une portion. La valeur par défaut est 2PI.
+		</p>
+		<p>
+		Cela crée une [name] basée sur les paramètres.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/OctahedronGeometry.html

@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr; [page:PolyhedronGeometry] &rarr;
+		<h1>[name]</h1>
+
+		<p class="desc">Une classe pour générer une géométrie d'octaèdre.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#OctahedronGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float radius], [param:Integer detail])</h3>
+		<p>
+		radius — Rayon de l'octaèdre. La valeur par défaut est 1.<br />
+		detail — La valeur par défaut est 0. Définir une valeur supérieure à zéro ajoute des sommets, la géométrie n'est donc plus un octaèdre.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:PolyhedronGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:PolyhedronGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/PlaneGeometry.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Une classe pour générer des géométries planes.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#PlaneGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code : </h2>
+
+		<code>const geometry = new THREE.PlaneGeometry( 1, 1 );
+		const material = new THREE.MeshBasicMaterial( {color: 0xffff00, side: THREE.DoubleSide} );
+		const plane = new THREE.Mesh( geometry, material );
+		scene.add( plane );
+		</code>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float width], [param:Float height], [param:Integer widthSegments], [param:Integer heightSegments])</h3>
+		<p>
+		width — Largeur le long de l'axe X. La valeur par défaut est 1.<br />
+		height — Hauteur le long de l'axe Y. La valeur par défaut est 1.<br />
+		widthSegments — Optional. Default is 1. <br />
+		heightSegments — Optional. Default is 1.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/PolyhedronGeometry.html

@@ -0,0 +1,68 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Un polyèdre est un solide en trois dimensions à faces planes. Cette classe prendra un tableau de sommets,
+			projetez-les sur une sphère, puis divisez-les jusqu'au niveau de détail souhaité. Cette classe est utilisée
+			par [page:DodecahedronGeometry], [page:IcosahedronGeometry], [page:OctahedronGeometry],
+			et [page:TetrahedronGeometry] pour générer leurs géométries respectives.
+		</p>
+
+		<h2>Exemple de code : </h2>
+<code>
+const verticesOfCube = [
+    -1,-1,-1,    1,-1,-1,    1, 1,-1,    -1, 1,-1,
+    -1,-1, 1,    1,-1, 1,    1, 1, 1,    -1, 1, 1,
+];
+
+const indicesOfFaces = [
+    2,1,0,    0,3,2,
+    0,4,7,    7,3,0,
+    0,1,5,    5,4,0,
+    1,2,6,    6,5,1,
+    2,3,7,    7,6,2,
+    4,5,6,    6,7,4
+];
+
+const geometry = new THREE.PolyhedronGeometry( verticesOfCube, indicesOfFaces, 6, 2 );
+</code>
+
+		<h2>Constructeur</h2>
+
+
+		<h3>[name]([param:Array vertices], [param:Array indices], [param:Float radius], [param:Integer detail])</h3>
+		<p>
+		vertices — [page:Array] de points de forme [1,1,1, -1,-1,-1, ... ] <br />
+		indices — [page:Array] d'indices qui composent les faces de forme [0,1,2, 2,3,0, ... ] <br />
+		radius — [page:Float] - Rayon de la forme finale <br />
+		detail — [page:Integer] - Combien de niveaux pour subdiviser la géométrie. Plus il y a de détails, plus la forme est lisse.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/RingGeometry.html

@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Une classe pour générer une géométrie d'anneau bidimensionnelle.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#RingGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code : </h2>
+
+		<code>const geometry = new THREE.RingGeometry( 1, 5, 32 );
+		const material = new THREE.MeshBasicMaterial( { color: 0xffff00, side: THREE.DoubleSide } );
+		const mesh = new THREE.Mesh( geometry, material );
+		scene.add( mesh );
+		</code>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float innerRadius], [param:Float outerRadius], [param:Integer thetaSegments], [param:Integer phiSegments], [param:Float thetaStart], [param:Float thetaLength])</h3>
+		<p>
+		innerRadius — La valeur par défaut est 0.5.<br />
+		outerRadius — La valeur par défaut est 1. <br />
+		thetaSegments — Nombre de segments. Un nombre plus élevé signifie que l'anneau sera plus rond. Le minimum est 3. La valeur par défaut est 8. <br />
+		phiSegments — Le minimum est 1. La valeur par défaut est 1.<br />
+		thetaStart —  Angle de départ. La valeur par défaut est 0.<br />
+		thetaLength — Angle central. La valeur par défaut est Math.PI * 2.
+		</p>
+
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/ShapeGeometry.html

@@ -0,0 +1,83 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Crée une géométrie polygonale unilatérale à partir d'une ou plusieurs formes de chemin.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#ShapeGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+
+		<h2>Exemple de code :</h2>
+
+
+		<code>
+		const x = 0, y = 0;
+
+		const heartShape = new THREE.Shape();
+
+		heartShape.moveTo( x + 5, y + 5 );
+		heartShape.bezierCurveTo( x + 5, y + 5, x + 4, y, x, y );
+		heartShape.bezierCurveTo( x - 6, y, x - 6, y + 7,x - 6, y + 7 );
+		heartShape.bezierCurveTo( x - 6, y + 11, x - 3, y + 15.4, x + 5, y + 19 );
+		heartShape.bezierCurveTo( x + 12, y + 15.4, x + 16, y + 11, x + 16, y + 7 );
+		heartShape.bezierCurveTo( x + 16, y + 7, x + 16, y, x + 10, y );
+		heartShape.bezierCurveTo( x + 7, y, x + 5, y + 5, x + 5, y + 5 );
+
+		const geometry = new THREE.ShapeGeometry( heartShape );
+		const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+		const mesh = new THREE.Mesh( geometry, material ) ;
+		scene.add( mesh );
+		</code>
+
+		<h2>Constructeur</h2>
+
+
+		<h3>[name]([param:Array shapes], [param:Integer curveSegments])</h3>
+		<p>
+		shapes — [page:Array] de formes ou une seule [page:Shape shape]. La valeur par défaut est un triangle.<br />
+		curveSegments - [page:Integer] - Nombre de segments par forme. La valeur par défaut est 12.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/SphereGeometry.html

@@ -0,0 +1,77 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Une classe pour générer des géométries de sphère.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#SphereGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code : </h2>
+
+		<code>const geometry = new THREE.SphereGeometry( 15, 32, 16 );
+		const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+		const sphere = new THREE.Mesh( geometry, material );
+		scene.add( sphere );
+		</code>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float radius], [param:Integer widthSegments], [param:Integer heightSegments], [param:Float phiStart], [param:Float phiLength], [param:Float thetaStart], [param:Float thetaLength])</h3>
+
+		<p>
+		radius — Rayon de la sphère. La valeur par défaut est 1.<br />
+		widthSegments — Nombre de segments horizontaux. La valeur minimale est 3 et la valeur par défaut est 32.<br />
+		heightSegments — Nombre de segments verticaux. La valeur minimale est 2 et la valeur par défaut est 16.<br />
+		phiStart — Spécifie l'angle de départ horizontal. La valeur par défaut est 0.<br />
+		phiLength — Spécifie la taille de l'angle de balayage horizontal. La valeur par défaut est Math.PI * 2. <br />
+		thetaStart — Spécifie l'angle de départ vertical. La valeur par défaut est 0.<br />
+		thetaLength — Spécifie la taille de l'angle de balayage vertical. La valeur par défaut est Math.PI.<br />
+		</p>
+
+		<p>
+		La géométrie est créée en balayant et en calculant les sommets autour de l'axe Y (balayage horizontal) et de l'axe Z (balayage vertical). Ainsi, des sphères incomplètes (semblables à des `'tranches de sphère'`) peuvent être créées en utilisant différentes valeurs de phiStart, phiLength, thetaStart et thetaLength, afin de définir les points auxquels nous commençons (ou terminons) le calcul de ces sommets.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/TetrahedronGeometry.html

@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr; [page:PolyhedronGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Une classe pour générer une géométrie de tétraèdre.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#TetrahedronGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float radius], [param:Integer detail])</h3>
+		<p>
+		radius — Rayon du tétraèdre. La valeur par défaut est 1.<br />
+		detail — La valeur par défaut est 0. Définir une valeur supérieure à 0 ajoute des sommets, la géométrie n'est donc plus un tétraèdre.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:PolyhedronGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:PolyhedronGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/TorusGeometry.html

@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Une classe pour générer des géométries de tore.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#TorusGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code : </h2>
+
+		<code>const geometry = new THREE.TorusGeometry( 10, 3, 16, 100 );
+		const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+		const torus = new THREE.Mesh( geometry, material );
+		scene.add( torus );
+		</code>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float radius], [param:Float tube], [param:Integer radialSegments], [param:Integer tubularSegments], [param:Float arc])</h3>
+		<p>
+		radius - Rayon du tore, du centre du tore au centre du tube. La valeur par défaut est 1.<br />
+		tube — Rayon du tube. La valeur par défaut est 0,4.<br />
+		radialSegments — La valeur par défaut est 8 <br />
+		tubularSegments — La valeur par défaut est 6. <br />
+		arc — Angle central. La valeur par défaut est Math.PI * 2.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/TorusKnotGeometry.html

@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Crée un nœud de tore, dont la forme particulière est définie par une paire d'entiers premiers entre eux, p et q. Si p et q ne sont pas premiers entre eux, le résultat sera un lien tore.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#TorusKnotGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code :</h2>
+
+		<code>const geometry = new THREE.TorusKnotGeometry( 10, 3, 100, 16 );
+		const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+		const torusKnot = new THREE.Mesh( geometry, material );
+		scene.add( torusKnot );
+		</code>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]([param:Float radius], [param:Float tube], [param:Integer tubularSegments], [param:Integer radialSegments], [param:Integer p], [param:Integer q])</h3>
+		<p>
+			<ul>
+				<li>radius - Rayon du tore. La valeur par défaut est 1.</li>
+				<li>tube — Rayon du tube. La valeur par défaut est 0,4.</li>
+				<li>tubularSegments — La valeur par défaut est 64.</li>
+				<li>radialSegments — La valeur par défaut est 8.</li>
+				<li>p — Cette valeur détermine combien de fois la géométrie s'enroule autour de son axe de symétrie de rotation. La valeur par défaut est 2.</li>
+				<li>q — Cette valeur détermine combien de fois la géométrie s'enroule autour d'un cercle à l'intérieur du tore. La valeur par défaut est 3.</li>
+			</ul>
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/TubeGeometry.html

@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Crée un tube qui s'extrude le long d'une courbe 3D.</p>
+
+		<iframe id="scene" src="scenes/geometry-browser.html#TubeGeometry"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Exemple de code :</h2>
+
+		<code>
+		class CustomSinCurve extends THREE.Curve {
+
+			constructor( scale = 1 ) {
+
+				super();
+
+				this.scale = scale;
+
+			}
+
+			getPoint( t, optionalTarget = new THREE.Vector3() ) {
+
+				const tx = t * 3 - 1.5;
+				const ty = Math.sin( 2 * Math.PI * t );
+				const tz = 0;
+
+				return optionalTarget.set( tx, ty, tz ).multiplyScalar( this.scale );
+
+			}
+
+		}
+
+		const path = new CustomSinCurve( 10 );
+		const geometry = new THREE.TubeGeometry( path, 20, 2, 8, false );
+		const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+		const mesh = new THREE.Mesh( geometry, material );
+		scene.add( mesh );
+		</code>
+
+		<h2>Constructeur</h2>
+
+
+		<h3>[name]([param:Curve path], [param:Integer tubularSegments], [param:Float radius], [param:Integer radialSegments], [param:Boolean closed])</h3>
+		<p>
+		path — [page:Curve] - Un chemin 3D qui hérite de la classe de base [page:Curve]. La valeur par défaut est une courbe de Bézier quadratique.<br />
+		tubularSegments — [page:Integer] - Le nombre de segments qui composent le tube. La valeur par défaut est '64'.<br />
+		radius — [page:Float] - Le rayon du tube. La valeur par défaut est '1'.<br />
+		radialSegments — [page:Integer] - Le nombre de segments qui composent la section. La valeur par défaut est '8'.<br />
+		closed — [page:Boolean] Spécifie si le tube est ouvert ou fermé. La valeur par défaut est `false`.<br />
+		</p>
+
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h3>[property:Object parameters]</h3>
+		<p>
+		Un objet avec une propriété pour chacun des paramètres du constructeur. Toute modification après instanciation ne change pas la géométrie.
+		</p>
+
+		<h3>[property:Array tangents]</h3>
+		<p>
+			Un tableau de tangentes [page:Vector3].
+		</p>
+
+		<h3>[property:Array normals]</h3>
+		<p>
+		Un tableau de normales [page:Vector3].
+		</p>
+
+		<h3>[property:Array binormals]</h3>
+		<p>
+		Un tableau de binormaux [page:Vector3].
+		</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/fr/geometries/WireframeGeometry.html

@@ -0,0 +1,56 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:BufferGeometry] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">Cela peut être utilisé comme objet d'assistance pour afficher une [page:BufferGeometry geometry] sous forme filaire.</p>
+
+		<h2>Exemple de code :</h2>
+
+		<code>
+		const geometry = new THREE.SphereGeometry( 100, 100, 100 );
+
+		const wireframe = new THREE.WireframeGeometry( geometry );
+
+		const line = new THREE.LineSegments( wireframe );
+		line.material.depthTest = false;
+		line.material.opacity = 0.25;
+		line.material.transparent = true;
+
+		scene.add( line );
+		</code>
+
+		<h2>Exemples</h2>
+
+		<p>
+			[example:webgl_helpers helpers]
+		</p>
+
+		<h2>Constructeur</h2>
+
+		<h3>[name]( [param:BufferGeometry geometry] )</h3>
+		<p>
+		geometry — Tout objet de géométrie.
+		</p>
+
+		<h2>Propriétés</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les propriétés communes.</p>
+
+		<h2>Méthodes</h2>
+		<p>Voir la classe de base [page:BufferGeometry] pour les méthodes communes.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/core/Object3D.html

@@ -328,7 +328,7 @@
       Questo metodo non supporta oggetti con genitore/i con scalabilità non uniforme.
 		</p>
 
-		<h3>[method:Array raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
+		<h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
 		<p>
       Metodo astratto (vuoto) per ottenere le intersezioni tra un raggio casted e questo oggetto.
       Sottoclassi come [page:Mesh], [page:Line], e [page:Points] implementano questo metodo per 

docs/api/it/materials/MeshLambertMaterial.html

@@ -17,7 +17,7 @@
 			Il materiale utilizza un modello [link:https://en.wikipedia.org/wiki/Lambertian_reflectance Lambertiano] non fisico
 			per calcolare la riflettanza. Questo può simulare bene alcune superfici (come legno o pietra non trattati),
 			ma non può simulare superfici lucide con riflessi speculari (come il legno verniciato). [name] utilizza 
-			l'ombreggiatura per-fragmet.<br /><br />
+			l'ombreggiatura per-fragment.<br /><br />
 
 			A causa della semplicità dei modelli della riflettanza e illuminazione, le prestazioni saranno maggiori
 			quando si utilizza questo materiale su [page:MeshPhongMaterial],	[page:MeshStandardMaterial] o [page:MeshPhysicalMaterial],

docs/api/it/materials/MeshPhongMaterial.html

@@ -17,7 +17,7 @@
 			Il materiale utilizza un modello [link:https://en.wikipedia.org/wiki/Blinn-Phong_shading_model Blinn-Phong] non fisico
 			per calcolare la riflettanza. A differenza dal modello Lambertiano utilizzato nel [page:MeshLambertMaterial]
 			questo può simulare superfici lucide con riflessi speculari (come il legno verniciato). [name] utilizza 
-			l'ombreggiatura per-fragmet.<br /><br />
+			l'ombreggiatura per-fragment.<br /><br />
 
 			Le prestazioni saranno maggiori quando si utilizza questo materiale su	[page:MeshStandardMaterial] o [page:MeshPhysicalMaterial],
 			a scapito di una certa precisione grafica.

docs/api/it/materials/MeshPhysicalMaterial.html

@@ -30,6 +30,9 @@
 			<li>
 				<b>Advanced reflectivity (riflettività avanzata):</b> Riflettività più flessibile per materiali non metallici.
 			</li>
+			<li>
+				<b>Sheen:</b> Can be used for representing cloth and fabric materials.
+			</li>
 		</ul>
 
 		<p>
@@ -63,6 +66,7 @@
 			[example:webgl_materials_variations_physical materials / variations / physical]<br />
 			[example:webgl_materials_physical_clearcoat materials / physical / clearcoat]<br />
 			[example:webgl_materials_physical_reflectivity materials / physical / reflectivity]<br />
+			[example:webgl_loader_gltf_sheen loader / gltf / sheen]<br />
 			[example:webgl_materials_physical_transmission materials / physical / transmission]
 		</p>
 

docs/api/it/math/Box2.html

@@ -0,0 +1,211 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Rappresenta un bounding box (rettangolo di selezione) allineato all'asse (AABB) nello spazio 2D.
+		</p>
+
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]( [param:Vector2 min], [param:Vector2 max] )</h3>
+		<p>
+		[page:Vector2 min] - (opzionale) [page:Vector2] che rappresenta il limite inferiore (x, y) del box.
+		Il valore predefinito è ( + Infinito, + Infinito ).<br>
+
+		[page:Vector2 max] - (opzionale) [page:Vector2] che rappresenta il limite superiore (x, y) del box.
+		Il valore predefinito è ( - Infinito, - Infinito ).<br /><br />
+
+		Crea un [name] delimitato da min e max.
+		</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Vector2 min]</h3>
+		<p>
+			[page:Vector2] che rappresenta il limite inferiore (x, y) del box.<br />
+			Il valore predefinito è ( + Infinito, + Infinito ).
+		</p>
+
+		<h3>[property:Vector2 max]</h3>
+		<p>
+			[page:Vector2] che rappresenta il limite superiore (x, y) del box.<br />
+			Il valore predefinito è ( - Infinito, - Infinito ).
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Vector2 clampPoint]( [param:Vector2 point], [param:Vector2 target] )</h3>
+		<p>
+		[page:Vector2 point] - [page:Vector2] da bloccare. <br>
+		[page:Vector2 target] - il risultato sarà copiato in questo Vector2.<br /><br />
+
+		[link:https://en.wikipedia.org/wiki/Clamping_(graphics) Blocca] il [page:Vector2 punto] entro i limiti di questo box.<br />
+		</p>
+
+		<h3>[method:Box2 clone]()</h3>
+		<p>Restituisce un nuovo [page:Box2] con lo stesso [page:.min min] e [page:.max max] di questo.</p>
+
+		<h3>[method:Boolean containsBox]( [param:Box2 box] )</h3>
+		<p>
+		[page:Box2 box] - [page:Box2 Box2] per testare l'inclusione.<br /><br />
+
+		Restituisce true se questo box include la totalità del [page:Box2 box]. Se questo e il [page:Box2 box] sono identici, 
+		questa funzione tornerà comunque true.
+		</p>
+
+		<h3>[method:Boolean containsPoint]( [param:Vector2 point] )</h3>
+		<p>
+		[page:Vector2 point] - [page:Vector2] per verificare l'inclusione.<br /><br />
+
+		Restituisce true se il [page:Vector2 punto] specificato si trova all'interno o sui limiti di questo box.
+		</p>
+
+		<h3>[method:this copy]( [param:Box2 box] )</h3>
+		<p>
+			Copia il [page:.min min] e il [page:.max max] da [page:Box2 box] a questo box.
+		</p>
+
+		<h3>[method:Float distanceToPoint]( [param:Vector2 point] )</h3>
+		<p>
+		[page:Vector2 point] - [page:Vector2] per misurare la distanza.<br /><br />
+
+		Restituisce la distanza da qualsiasi arco di questo box al punto specificato.
+		Se il [page:Vector2 punto] si trova all'interno di questo box, la distanza sarà 0.
+		</p>
+
+		<h3>[method:Boolean equals]( [param:Box2 box] )</h3>
+		<p>
+		[page:Box2 box] - Box da confrontare con questo.<br /><br />
+
+		Restituisce true se questo box e il [page:Box2 box] condividono gli stessi limiti inferiori e superiori.
+		</p>
+
+		<h3>[method:this expandByPoint]( [param:Vector2 point] )</h3>
+		<p>
+		[page:Vector2 point] - [page:Vector2] che dovrebbe essere incluso nel box.<br /><br />
+
+		Espande i limiti di questo box in modo da includere il [page:Vector2 punto].
+		</p>
+
+		<h3>[method:this expandByScalar]( [param:Float scalar] )</h3>
+		<p>
+		[page:Float scalar] - Distanza di cui espandere il box.<br /><br />
+
+		Espande ogni dimensione del box per lo [page:Float scalare]. Se negativo, le dimensioni del box saranno contratte.
+		</p>
+
+		<h3>[method:this expandByVector]( [param:Vector2 vector] )</h3>
+		<p>
+		[page:Vector2 vector] - [page:Vector2] per il quale espandere il box.<br /><br />
+
+		Espande questo box in modo equilatero per [page:Vector2 vettore]. La larghezza di questo box sarà estesa
+		dal componente x del [page:Vector2 vettore] in entrambe le direzioni. L'altezza di questo box 
+		sarà estesa dal componente y del [page:Vector2 vettore] in entrambe le direzioni.
+		</p>
+
+		<h3>[method:Vector2 getCenter]( [param:Vector2 target] )</h3>
+		<p>
+		[page:Vector2 target] — il risultato sarà copiato in questo Vector2.<br /><br />
+
+		Restituisce il punto centrale del box come [page:Vector2]. 
+		</p>
+
+		<h3>[method:Vector2 getParameter]( [param:Vector2 point], [param:Vector2 target] ) </h3>
+		<p>
+		[page:Vector2 point] - [page:Vector2].<br/>
+		[page:Vector2 target] - il risultato sarà copiato in questo Vector2.<br /><br />
+
+		Restituisce un punto come proporzione della larghezza e dell'altezza di questo box.
+		</p>
+
+		<h3>[method:Vector2 getSize]( [param:Vector2 target] )</h3>
+		<p>
+		[page:Vector2 target] - il risultato sarà copiato in questo Vector2.<br /><br />
+
+		Restituisce la larghezza e l'altezza di questo box.
+		</p>
+
+		<h3>[method:this intersect]( [param:Box2 box] )</h3>
+		<p>
+		[page:Box2 box] - Box con cui intersecare.<br /><br />
+
+		Restituisce l'intersezione di questo box e [page:Box2 box], impostando il limite superiore di questo box al minore
+		dei limiti superiori dei due box e il limite inferiore di questo box al maggiore dei limiti inferiori dei due box.
+		</p>
+
+		<h3>[method:Boolean intersectsBox]( [param:Box2 box] )</h3>
+		<p>
+		[page:Box2 box] - Box per il controllo dell'intersezione.<br /><br />
+
+		Determina se questo box interseca [page:Box2 box] oppure no.
+		</p>
+
+		<h3>[method:Boolean isEmpty]()</h3>
+		<p>
+			Restituisce true se questo box include zero punti entro i suoi limiti.<br>
+			Si noti che un box con i limiti superiore e inferiore uguali include ancora un punto,
+			quello condiviso da entrambi i limiti.
+		</p>
+
+		<h3>[method:this makeEmpty]()</h3>
+		<p>Rende questo box vuoto.</p>
+
+
+		<h3>[method:this set]( [param:Vector2 min], [param:Vector2 max] )</h3>
+		<p>
+			[page:Vector2 min] - (obbligatorio) [page:Vector2] che rappresenta il limite inferiore (x, y) del box. <br>
+			[page:Vector2 max]  - (obbligatorio) [page:Vector2] che rappresenta il limite superiore (x, y) del box. <br /><br />
+
+			Imposta i limiti inferiore e superiore (x, y) di questo box.<br>
+			Si noti che questo metodo copia solo i valori dagli oggetti dati.
+		</p>
+
+		<h3>[method:this setFromCenterAndSize]( [param:Vector2 center], [param:Vector2 size] )</h3>
+		<p>
+		[page:Vector2 center] - Posizione centrale desiderata del box ([page:Vector2]). <br>
+		[page:Vector2 size] - Dimensioni x e y desiderati per il box ([page:Vector2]).<br /><br />
+
+		Centra questo box nel [page:Vector2 centro] e imposta la larghezza e l'altezza di questo box ai valori 
+		specificati in [page:Vector2 size].
+		</p>
+
+		<h3>[method:this setFromPoints]( [param:Array points] )</h3>
+		<p>
+		[page:Array points] - Array di [page:Vector2 Vector2] che conterrà il box risultante.<br /><br />
+
+		Imposta i limiti inferiore e superiore di questo box per includere tutti i punti in [page:Array points].
+		</p>
+
+		<h3>[method:this translate]( [param:Vector2 offset] )</h3>
+		<p>
+		[page:Vector2 offset] - Direzione e distanza dell'offset.<br /><br />
+
+		Aggiunge l'[page:Vector2 offset] ad entrambi i limiti inferiore e superiore di questo box, spostando efficacemente
+		le unità di [page:Vector2 offset] di questo box nello spazio 2D.
+		</p>
+
+		<h3>[method:this union]( [param:Box2 box] )</h3>
+		<p>
+		[page:Box2 box] - Box che verrà unito con questo box.<br /><br />
+
+		Unisce questo box con [page:Box2 box], impostando il limite superiore di questo box al maggiore dei limiti superiori 
+		di entrambi i box e il limite inferiore di questo box al minore dei limiti inferiori di entrambi i box.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Box3.html

@@ -0,0 +1,310 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Rappresenta un bounding box (rettangolo di selezione) allineato all'asse (AABB) nello spazio 3D.
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const box = new THREE.Box3();
+
+		const mesh = new THREE.Mesh(
+			new THREE.SphereGeometry(),
+			new THREE.MeshBasicMaterial()
+		);
+
+		// assicurarsi che il bounding box sia calcolato per la sua geometria
+		// questo dovrebbe essere fatto una sola volta (supponendo geometrie statiche)
+		mesh.geometry.computeBoundingBox();
+
+		// ...
+
+		// nel ciclo di animazione, calcola il bounding box corrente con la matrice world
+		box.copy( mesh.geometry.boundingBox ).applyMatrix4( mesh.matrixWorld );
+		</code>
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]( [param:Vector3 min], [param:Vector3 max] )</h3>
+		<p>
+		[page:Vector3 min] - (opzionale) [page:Vector3] che rappresenta il limite inferiore (x, y, z) del box.
+		Il valore predefinito è ( + Infinito, + Infinito, + Infinito ).<br>
+
+		[page:Vector3 max] - (opzionale) [page:Vector3] che rappresenta il limite superiore (x, y, z) del box.
+		Il valore predefinito è ( - Infinito, - Infinito, - Infinito ).<br /><br />
+
+		Crea un [name] delimitato da min e max.
+		</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Boolean isBox3]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h3>[property:Vector3 min]</h3>
+		<p>
+			[page:Vector3] rappresenta il limite inferiore (x, y, z) del box.<br />
+			Il valore predefinito è ( + Infinito, + Infinito, + Infinito ).
+		</p>
+
+		<h3>[property:Vector3 max]</h3>
+		<p>
+			[page:Vector3] che rappresenta il limite superiore (x, y, z) del box.<br />
+			Il valore predefinito è ( - Infinito, - Infinito, - Infinito ).
+		</p>
+
+
+
+		<h2>Metodi</h2>
+
+		<h3>[method:this applyMatrix4]( [param:Matrix4 matrix] )</h3>
+		<p>
+		[page:Matrix4 matrix] - La [page:Matrix4] da applicare<br /><br />
+
+		Trasforma questo Box3 con la matrice fornita.
+		</p>
+
+		<h3>[method:Vector3 clampPoint]( [param:Vector3 point], [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 point] - [page:Vector3] da bloccare. <br>
+		[page:Vector3 target] - il risultato sarà copiato in questo Vector3.<br /><br />
+
+		[link:https://en.wikipedia.org/wiki/Clamping_(graphics) Blocca] il [page:Vector3 punto] entro i limiti di questo box.<br />
+		</p>
+
+		<h3>[method:Box3 clone]()</h3>
+		<p>Restituisce un nuovo [page:Box3] con lo stesso [page:.min min] e [page:.max max] di questo.</p>
+
+		<h3>[method:Boolean containsBox]( [param:Box3 box] )</h3>
+		<p>
+			[page:Box3 box] - [page:Box3 Box3] per testare l'inclusione.<br /><br />
+
+			Restituisce true se questo box include la totalità del [page:Box3 box]. Se questo e il [page:Box3 box] sono identici, 
+			questa fuonzione tornerà comunque true.
+		</p>
+
+		<h3>[method:Boolean containsPoint]( [param:Vector3 point] )</h3>
+		<p>
+		[page:Vector3 point] - [page:Vector3] per verificare l'inclusione.<br /><br />
+
+		Restituisce true se il [page:Vector3 punto] specificato si trova all'interno o sui limiti di questo box.
+		</p>
+
+		<h3>[method:this copy]( [param:Box3 box] )</h3>
+		<p>
+		[page:Box3 box]  - [page:Box3] da copiare.<br /><br />
+
+		Copia il [page:.min min] e il [page:.max max] da [page:Box3 box] a questo box.
+		</p>
+
+		<h3>[method:Float distanceToPoint]( [param:Vector3 point] )</h3>
+		<p>
+		[page:Vector3 point] - [page:Vector3] per misurare la distanza.<br /><br />
+
+		Restituisce la distanza da qualsiasi arco di questo box al punto specificato.
+		Se il [page:Vector3 punto] si trova all'interno di questo box, la distanza sarà 0.
+		</p>
+
+
+		<h3>[method:Boolean equals]( [param:Box3 box] )</h3>
+		<p>
+		[page:Box3 box] - Box da confrontare con questo.<br /><br />
+
+		Restituisce true se questo box e il [page:Box3 box] condividono gli stessi limiti inferiore e superiore.
+		</p>
+
+		<h3>[method:this expandByObject]( [param:Object3D object], [param:Boolean precise] )</h3>
+		<p>
+			[page:Object3D object] - [page:Object3D] per espandere il box.<br />
+			precise - (opzionale) espande il bounding box il meno possibile a scapito di ulteriori calcoli. L'impostazione predefinita è `false`.<br /><br />
+
+			Espande i limiti di questo box per includere l'[page:Object3D oggetto] e i suoi figli,
+			tenendo conto delle trasformazioni del mondo dell'oggetto e dei figli.
+			La funzione può risultare in un box più grande del necessario (a meno che il parametro non sia impostato su true).
+		</p>
+
+		<h3>[method:this expandByPoint]( [param:Vector3 point] )</h3>
+		<p>
+		[page:Vector3 point] - [page:Vector3] che dovrebbe essere incluso nel box.<br /><br />
+
+		Espande i limiti di questo box in modo da includere il [page:Vector3 punto].
+		</p>
+
+		<h3>[method:this expandByScalar]( [param:Float scalar] )</h3>
+		<p>
+		[page:Float scalar] - Distanza di cui espandere il box.<br /><br />
+
+		Espande ogni dimensione del box per lo [page:Float scalare]. Se negativo, le dimensioni del box saranno contratte.
+		</p>
+
+		<h3>[method:this expandByVector]( [param:Vector3 vector] )</h3>
+		<p>
+		[page:Vector3 vector] - [page:Vector3] per il quale espandere il box.<br /><br />
+
+		Espande questo box in modo equilatero per [page:Vector3 vettore]. La larghezza di questo box sarà estesa
+		dal componente x del [page:Vector3 vettore] in entrambe le direzioni. L'altezza di questo box 
+		sarà estesa dal componente y del [page:Vector3 vettore] in entrambe le direzioni.
+		La profondità di questo box sarà estesa dal componente z del [page:Vector3 vettore] in entrambe le direzioni.
+		</p>
+
+		<h3>[method:Sphere getBoundingSphere]( [param:Sphere target] )</h3>
+		<p>
+		[page:Sphere target] - il risultato sarà copiato in questa sfera.<br /><br />
+
+		Ottiene una [page:Sphere Sfera] che delimita il box.
+		</p>
+
+		<h3>[method:Vector3 getCenter]( [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 target] - il risultato sarà copiato in questo Vector3.<br /><br />
+
+		Restituisce il punto centrale del box come un [page:Vector3]. 
+		</p>
+
+		<h3>[method:Vector3 getParameter]( [param:Vector3 point], [param:Vector3 target] ) </h3>
+		<p>
+		[page:Vector3 point] - [page:Vector3].<br/>
+		[page:Vector3 target] - il risultato sarà copiato in questo Vector3.<br /><br />
+
+		Restituisce un punto come proporzione della larghezza, dell'altezza e della profondità di questo box.
+		</p>
+
+		<h3>[method:Vector3 getSize]( [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 target] - il risultato sarà copiato in questo Vector3.<br /><br />
+
+		Restituisce la larghezza, l'altezza e la profondità di questo box.
+		</p>
+
+		<h3>[method:this intersect]( [param:Box3 box] )</h3>
+		<p>
+		[page:Box3 box] - Box con cui intersecare.<br /><br />
+
+		Restituisce l'intersezione di questo box e [page:Box3 box], impostando il limite superiore di questo box al minore
+		dei limiti superiori dei due box e il limite inferiore di questo box al maggiore dei limiti inferiori dei due box.
+		Se non ci sono sovrapposizioni, rende il box vuoto.
+		</p>
+
+		<h3>[method:Boolean intersectsBox]( [param:Box3 box] )</h3>
+		<p>
+		[page:Box3 box] - Box per il controllo dell'intersezione.<br /><br />
+
+		Determina se questo box interseca [page:Box3 box] oppure no.
+		</p>
+
+		<h3>[method:Boolean intersectsPlane]( [param:Plane plane] )</h3>
+		<p>
+		[page:Plane plane] - [page:Plane] per il controllo dell'intersezione.<br /><br />
+
+		Determina se questo box interseca il [page:Plane plane] oppure no.
+		</p>
+
+		<h3>[method:Boolean intersectsSphere]( [param:Sphere sphere] )</h3>
+		<p>
+		[page:Sphere sphere] - [page:Sphere] per il controllo dell'intersezione.<br /><br />
+
+		Determina se questo box interseca la [page:Sphere sphere] oppure no.
+		</p>
+
+		<h3>[method:Boolean intersectsTriangle]( [param:Triangle triangle] )</h3>
+		<p>
+		[page:Triangle triangle] - [page:Triangle] per il controllo dell'intersezione.<br /><br />
+
+		Determina se questo box interseca il [page:Triangle triangle] oppure no.
+		</p>
+
+		<h3>[method:Boolean isEmpty]()</h3>
+		<p>
+			Restituisce true se questo box include zero punti entro i suoi limiti.<br>
+			Si noti che un box con i limiti superiore e inferiore uguali include ancora un punto,
+			quello condiviso da entrambi i limiti.
+		</p>
+
+		<h3>[method:this makeEmpty]()</h3>
+		<p>Rende questo box vuoto.</p>
+
+		<h3>[method:this set]( [param:Vector3 min], [param:Vector3 max] )</h3>
+		<p>
+		[page:Vector3 min] - [page:Vector3] rappresenta il limite inferiore (x, y, z) del box.<br />
+		[page:Vector3 max] - [page:Vector3] rappresenta il limite superiore (x, y, z) del box.<br /><br />
+
+		Imposta i limiti inferiore e superiore (x, y, z) di questo box.<br>
+		Si noti che questo metodo copia solo i valori dagli oggetti dati.
+		</p>
+
+		<h3>[method:this setFromArray]( [param:Array array] )</h3>
+		<p>
+		array -- Un array di dati di posizione che il box risultante avvolgerà.<br /><br />
+
+		Imposta i limiti inferiore e superiore di questo box per includere tutti i dati nell'`array`.
+		</p>
+
+		<h3>[method:this setFromBufferAttribute]( [param:BufferAttribute attribute] )</h3>
+		<p>
+		[page:BufferAttribute attribute] - Un attributo buffer di dati di posizione che il box risultante avvolgerà.<br /><br />
+
+		Imposta i limiti inferiore e superiore di questo box per includere tutti i dati nell'[page:BufferAttribute attribute].
+		</p>
+
+		<h3>[method:this setFromCenterAndSize]( [param:Vector3 center], [param:Vector3 size] )</h3>
+		<p>
+		[page:Vector3 center] - Posizione centrale desiderata del box.<br>
+		[page:Vector3 size] - Dimensioni x, y e z desiderati per il box.<br /><br />
+
+		Centra questo box nel [page:Vector3 centro] e imposta la larghezza e l'altezza di questo box ai valori 
+		specificati in [page:Vector3 size].
+		</p>
+
+		<h3>[method:this setFromObject]( [param:Object3D object], [param:Boolean precise] )</h3>
+		<p>
+		[page:Object3D object] - [page:Object3D] di cui calcolare il bounding box.<br />
+		precise - (opzionale) calcola il più piccolo bounding box all'asse world a scapito di più calcoli. L'impostazione predefinita è `false`.<br /><br />
+
+		Calcola il bounding box allineato all'asse world di un [page:Object3D] (inclusi i suoi figli),
+		tenendo conto delle trasformazioni del mondo dell'oggetto e dei bambini. La funzione
+		può comportare un box più grande del necessario.
+		</p>
+
+		<h3>[method:this setFromPoints]( [param:Array points] )</h3>
+		<p>
+		[page:Array points] - Array di [page:Vector3 Vector3] che conterrà il box risultante.<br /><br /> 
+
+		Imposta i limiti inferiore e superiore di questo box per includere tutti i punti in [page:Array points].
+		</p>
+
+		<h3>[method:this translate]( [param:Vector3 offset] )</h3>
+		<p>
+		[page:Vector3 offset] - Direzione e distanza dell'offset.<br /><br />
+
+		Aggiunge l'[page:Vector3 offset] ad entrambi i limiti inferiore e superiore di questo box, spostando efficacemente
+		le unità di page:Vector3 offset] di questo box nello spazio 3D.
+		</p>
+
+		<h3>[method:this union]( [param:Box3 box] )</h3>
+		<p>
+		[page:Box3 box] - Box che verrà unito con questo box.<br /><br />
+
+		Calcola l'unione di questo box con [page:Box3 box], impostando il limite superiore di questo box al maggiore dei limiti superiori 
+		di entrambi i box e il limite inferiore di questo box al minore dei limiti inferiori di entrambi i box.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Color.html

@@ -0,0 +1,321 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Classe che rappresenta un colore.
+		</p>
+
+		<p>
+			L'iterazione di un'istanza [name] produrrà i suoi componenti (r, g, b) nell'ordine corrispondente.
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<p>
+			Un colore può essere inizializzato in qualsiasi dei seguenti modi:
+		</p>
+		<code>
+// Un costruttore vuoto - per impostazione predefinita sarà bianco
+const color1 = new THREE.Color();
+
+// Colore esadecimale (raccomandato)
+const color2 = new THREE.Color( 0xff0000 );
+
+// Una stringa RGB
+const color3 = new THREE.Color("rgb(255, 0, 0)");
+const color4 = new THREE.Color("rgb(100%, 0%, 0%)");
+
+// Nome del colore X11 - tutti i 140 nomi dei colori sono supportati.
+// Si noti la mancanza del CamelCase nel nome
+const color5 = new THREE.Color( 'skyblue' );
+
+// Una stringa HSL
+const color6 = new THREE.Color("hsl(0, 100%, 50%)");
+
+// Separa i valori RGB tra 0 e 1
+const color7 = new THREE.Color( 1, 0, 0 );
+		</code>
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]( [param:Color_Hex_or_String r], [param:Float g], [param:Float b] )</h3>
+		<p>
+		[page:Color_Hex_or_String r] - (opzionale) Se gli argomenti [page:Float g] e [page:Float b] sono definiti, indica il componente rosso del colore.
+		Se non sono definiti, questo può essere una [link:https://en.wikipedia.org/wiki/Web_colors#Hex_triplet tripletta esadecimale] (consigliato), 
+		una stringa CSS-style, o un'altra istanza Color.<br />
+		[page:Float g] - (opzionale) Se è definito, indica la componente verde del colore.<br />
+		[page:Float b] - (opzionale) Se è definito, indica la componente blu del colore.<br /><br />
+
+		Si noti che il metodo standard per definire il colore in three.js è con una [link:https://en.wikipedia.org/wiki/Web_colors#Hex_triplet tripletta esadecimale],
+		questo metodo viene utilizzato nel resto della documentazione.<br /><br />
+
+		Quando tutti gli argomenti sono definiti allora [page:Color_Hex_or_String r] è il componente rosso,
+		[page:Float g] è il componente verde e [page:Float b] è il componente blue del colore.<br />
+		Quando solo [page:Color_Hex_or_String r] è definito:<br />
+		<ul>
+			<li>Può essere una [link:https://en.wikipedia.org/wiki/Web_colors#Hex_triplet tripletta esadecimale] che rappresenta il colore (consigliato).</li>
+			<li>Può essere un'altra istanza di Color.</li>
+			<li>Può essere una stringa CSS-style. Per esempio:
+				<ul>
+					<li>'rgb(250, 0,0)'</li>
+					<li>'rgb(100%,0%,0%)'</li>
+					<li>'hsl(0, 100%, 50%)'</li>
+					<li>'#ff0000'</li>
+					<li>'#f00'</li>
+					<li>'red'</li>
+				</ul>
+
+			</li>
+		</ul>
+		</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Boolean isColor]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h3>[property:Float r]</h3>
+		<p>
+			Valore del canale rosso tra 0 e 1. Il valore predefinito è 1.
+		</p>
+
+		<h3>[property:Float g]</h3>
+		<p>
+			Valore del canale verde tra 0 e 1. Il valore predefinito è 1.
+		</p>
+
+		<h3>[property:Float b]</h3>
+		<p>
+			Valore del canale blu tra 0 e 1. Il valore predefinito è 1.
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:this add]( [param:Color color] ) </h3>
+		<p>Aggiunge i valori RGB del [page:Color colore] ai valori RGB di questo colore.</p>
+
+		<h3>[method:this addColors]( [param:Color color1], [param:Color color2] ) </h3>
+		<p>Imposta questi valori RGB del colore alla somma dei valori RGB di [page:Color color1] e [page:Color color2].</p>
+
+		<h3>[method:this addScalar]( [param:Number s] ) </h3>
+		<p>Aggiunge [page:Number s] ai valori RGB di questo colore.</p>
+
+		<h3>[method:Color clone]() </h3>
+		<p>Restituisce un nuovo Color con gli stessi valori [page:.r r], [page:.g g] e [page:.b b] di questo.</p>
+
+		<h3>[method:this copy]( [param:Color color] ) </h3>
+		<p>
+			Copia i parametri [page:.r r], [page:.g g] e [page:.b b] dal [page:Color colore] in questo colore.
+		</p>
+
+		<h3>[method:this convertLinearToSRGB]() </h3>
+		<p>
+			Converte questo colore dallo spazio lineare allo spazio sRGB.
+		</p>
+
+		<h3>[method:this convertSRGBToLinear]() </h3>
+		<p>
+			Converte questo colore dallo spazio sRGB allo spazio lineare.
+		</p>
+
+		<h3>[method:this copyLinearToSRGB]( [param:Color color] ) </h3>
+		<p>
+		[page:Color color] - Colore da copiare.<br /><br />
+
+		Copia il colore passato in questo colore, e poi converte questo colore dallo spazio lineare allo spazio sRGB.
+		</p>
+
+		<h3>[method:this copySRGBToLinear]( [param:Color color] ) </h3>
+		<p>
+		[page:Color color] - Colore da copiare.<br /><br />
+
+		Copia il colore passato in questo colore, e poi converte questo colore dallo spazio sRGB allo spazio lineare.
+		</p>
+
+		<h3>[method:Boolean equals]( [param:Color color] ) </h3>
+		<p>Compara i valori RGB del [page:Color colore] con quelli di questo oggetto. Restituisce true se sono gli stessi, false altrimenti.</p>
+
+		<h3>[method:this fromArray]( [param:Array array], [param:Integer offset] ) </h3>
+		<p>
+		[page:Array array] - [page:Array] di float nella forma [ [page:Float r], [page:Float g], [page:Float b] ].<br />
+		[page:Integer offset] - Un offset opzionale nell'array.<br /><br />
+
+		Imposta i componenti di questo colore in base a un array formattato come [ [page:Float r], [page:Float g], [page:Float b] ].
+		</p>
+
+		<h3>[method:this fromBufferAttribute]( [param:BufferAttribute attribute], [param:Integer index] )</h3>
+		<p>
+		[page:BufferAttribute attribute] - l'attributo sorgente.<br />
+		[page:Integer index] - l'indice dell'attributo.<br /><br />
+
+		Imposta i componenti del colore dall'[page:BufferAttribute attributo].
+		</p>
+
+		<h3>[method:Integer getHex]( [param:string colorSpace] = SRGBColorSpace )</h3>
+		<p>Restituisce il valore esadecimale di questo colore.</p>
+
+		<h3>[method:String getHexString]( [param:string colorSpace] = SRGBColorSpace )</h3>
+		<p>Restituisce il valore esadecimale di questo colore come una stringa (per esempio, 'FFFFFF').</p>
+
+		<h3>[method:Object getHSL]( [param:Object target], [param:string colorSpace] = LinearSRGBColorSpace )</h3>
+		<p>
+			[page:Object target] - questo risultato sarà copiato in questo Oggetto. Aggiunge le chiavi h, s e l all'oggetto (se non è già presente).<br /><br />
+
+			Converte i valori [page:.r r], [page:.g g] e [page:.b b] del Color al formato [link:https://en.wikipedia.org/wiki/HSL_and_HSV HSL]
+			e restituisce un oggetto della forma:
+
+			<code>
+				{ h: 0, s: 0, l: 0 }
+			</code>
+
+		</p>
+
+		<h3>[method:String getStyle]( [param:string colorSpace] = SRGBColorSpace )</h3>
+		<p>Restituisce il valore di questo colore come una stringa CSS style. Esempio: `rgb(255,0,0)`.</p>
+
+		<h3>[method:this lerp]( [param:Color color], [param:Float alpha] ) </h3>
+		<p>
+		[page:Color color] - colore su cui convergere.<br />
+		[page:Float alpha] - fattore di interpolazione nell'intervallo chiuso `[0, 1]`.<br /><br />
+
+		Interpola linearmente i valori RGB di questo colore verso i valori RGB dell'argomento passato.
+		L'argomento alfa può essere considerato come il rapporto tra i due colori, dove `0.0` è
+		questo colore e `1.0` è il primo argomento.
+		</p>
+
+		<h3>[method:this lerpColors]( [param:Color color1], [param:Color color2], [param:Float alpha] )</h3>
+		<p>
+		[page:Color color1] - [page:Color colore] iniziale.<br />
+		[page:Color color2] - [page:Color colore] verso cui interpolare.<br />
+		[page:Float alpha] - fattore interpolazione, tipicamente nell'intervallo chiuso `[0, 1]`.<br /><br />
+
+		Imposta questo colore per essere il colore interpolato linearmente tra [page:Color color1] e
+		[page:Color color2] dove alfa è la distanza percentuale lungo la linea che collega i due colori
+		- alfa = 0 sarà [page:Color color1], e alpha = 1 sarà [page:Color color2].
+		</p>
+
+		<h3>[method:this lerpHSL]( [param:Color color], [param:Float alpha] ) </h3>
+		<p>
+		[page:Color color] - colore su cui convergere.<br />
+		[page:Float alpha] - fattore di interpolazione nell'intervallo chiuso`[0, 1]`.<br /><br />
+
+		Interpola linearmente i valori HSL di questo colore verso i valori HSL dell'argomento passato.
+		Si differenzia dal classico [page:.lerp] non interpolando direttamente da un colore all'altro,
+		ma passando invece attraverso tutte le sfumature tra questi due colori.
+		L'argomento alfa può essere considerato come il rapporto tra i due colori, dove `0.0` è
+		questo colore e `1.0` è il primo argomento.
+		</p>
+
+		<h3>[method:this multiply]( [param:Color color] ) </h3>
+		<p>Moltiplica i valori RGB di questo colore per i valori RGB del colore passato.</p>
+
+		<h3>[method:this multiplyScalar]( [param:Number s] ) </h3>
+		<p>Moltiplica i valori RGB di questo colore per [page:Number s].</p>
+
+		<h3>[method:this offsetHSL]( [param:Float h], [param:Float s], [param:Float l] ) </h3>
+		<p>
+			Aggiunge [page:Float h], [page:Float s] e [page:Float l] passati ai valori di questo colore.
+			Internamente, converte i valori [page:.r r], [page:.g g] e [page:.b b] del colore a HSL,
+			aggiunge [page:Float h], [page:Float s], e [page:Float l] e poi converte il colore nero a RGB.
+		</p>
+
+		<h3>[method:this set]( [param:Color_Hex_or_String value] ) </h3>
+		<p>
+		[page:Color_Hex_or_String value] - Valore a cui impostare il valore.<br /><br />
+
+		Vedi il costruttore sopra per i dettagli completi di quale [page:Color_Hex_or_String valore] può assumere.
+		Delega a [page:.copy], [page:.setStyle], o [page:.setHex] a seconda del tipo di input.
+		</p>
+
+		<h3>[method:this setHex]( [param:Integer hex], [param:string colorSpace] = SRGBColorSpace ) </h3>
+		<p>
+		[page:Integer hex] - formato [link:https://en.wikipedia.org/wiki/Web_colors#Hex_triplet tripletta esadecimale].<br /><br />
+
+		Imposta questo colore da un valore esadecimale.
+		</p>
+
+		<h3>[method:this setHSL]( [param:Float h], [param:Float s], [param:Float l], [param:string colorSpace] = LinearSRGBColorSpace ) </h3>
+		<p>
+		[page:Float h] - Valore di tonalità compreso tra 0.0 e 1.0 <br />
+		[page:Float s] - Valore di saturazione compreso tra 0.0 e 1.0 <br />
+		[page:Float l] - Valore di luminosità compreso tra 0.0 e 1.0<br /><br />
+
+		Imposta il colore dai valori HSL.
+		</p>
+
+		<h3>[method:this setRGB]( [param:Float r], [param:Float g], [param:Float b], [param:string colorSpace] = LinearSRGBColorSpace ) </h3>
+		<p>
+		[page:Float r] - Valore del canale rosso tra 0.0 e 1.0.<br />
+		[page:Float g] - Valore del canale verde tra 0.0 e 1.0.<br />
+		[page:Float b] - Valore del canale blu tra 0.0 e 1.0.<br /><br />
+
+		Imposta questo colore dai valori RGB.
+		</p>
+
+		<h3>[method:this setScalar]( [param:Float scalar] ) </h3>
+		<p>
+		[page:Float scalar] - un valore tra 0.0 e 1.0.<br /><br />
+
+		Imposta tutti e tre i componenti del colore al valore [page:Float scalare].
+		</p>
+
+		<h3>[method:this setStyle]( [param:String style], [param:string colorSpace] = SRGBColorSpace ) </h3>
+		<p>
+		[page:String style] - colore come una stringa CSS-style.<br /><br />
+
+		Imposta questo colore da una stringa CSS. Per esempio,
+		"rgb(250, 0,0)",
+		"rgb(100%, 0%, 0%)",
+		"hsl(0, 100%, 50%)",
+		"#ff0000",
+		"#f00", o
+		"red" ( o qualsiasi [link:https://en.wikipedia.org/wiki/X11_color_names#Color_name_chart nome dei colori X11]
+		- tutti i 140 nomi dei colori sono supportati ).<br />
+
+		Sono accettati anche colori traslucidi come "rgba(255, 0, 0, 0.5)" e "hsla(0, 100%, 50%, 0.5)",
+		ma le coordinate del canale alfa verranno eliminate.<br /><br />
+
+		Si noti che per i nomi dei colori X11, più parole come Dark Orange diventano la stringa 'darkorange'.
+		</p>
+
+		<h3>[method:this setColorName]( [param:String style], [param:string colorSpace] = SRGBColorSpace ) </h3>
+		<p>
+		[page:String style] - nome del colore ( dai [link:https://en.wikipedia.org/wiki/X11_color_names#Color_name_chart nomi dei colori X11] ).<br /><br />
+
+		Imposta questo colore dal nome del colore. Più veloce del metodo [page:.setStyle] se non hai bisogno di altri formati in stile CSS.<br/><br/>
+
+		Per convenienza, la lista dei nomi è esposta in Color.NAMES come un hash: <code>Color.NAMES.aliceblue // returns 0xF0F8FF</code>
+		</p>
+
+		<h3>[method:this sub]( [param:Color color] ) </h3>
+		<p>
+			Sottrae i componenti RGB del colore dato dai componenti RGB di questo colore.
+			Se questo ritorna un componente negativo, tale componente viene impostato a zero.
+		</p>
+
+		<h3>[method:Array toArray]( [param:Array array], [param:Integer offset] ) </h3>
+		<p>
+		[page:Array array] - Un array opzionale in cui memorizzare il colore. <br />
+		[page:Integer offset] - Un offset opzionale nell'array.<br /><br />
+
+		Restituisce un array della forma [ r, g, b ].
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Cylindrical.html

@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			[link:https://en.wikipedia.org/wiki/Cylindrical_coordinate_system Coordinate cilindriche] di un punto.
+		</p>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( [param:Float radius], [param:Float theta], [param:Float y] )</h3>
+		<p>
+		[page:Float radius] - distanza dall'origine a un punto nel piano x-z.
+		Il valore predefinito è `1.0`.<br />
+		[page:Float theta] - angolo in senso antiorario nel piano x-z misurato in radianti dall'asse z positivo.
+		Il valore predefinito è `0`.<br />
+		[page:Float y] - altezza sopra il piano x-z. Il valore predefinito è `0`.
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Float radius]</h3>
+
+		<h3>[property:Float theta]</h3>
+
+		<h3>[property:Float y]</h3>
+
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Cylindrical clone]()</h3>
+		<p>
+			Restituisce un nuovo cilindro con le stesse proprietà [page:.radius radius], [page:.theta theta]
+			e [page:.y y] di questo.
+		</p>
+
+		<h3>[method:this copy]( [param:Cylindrical other] )</h3>
+		<p>
+			Copia i valori delle proprietà [page:.radius radius], [page:.theta theta]
+			e [page:.y y] del cilindro passato in questo cilindro.
+		</p>
+
+		<h3>[method:this set]( [param:Float radius], [param:Float theta], [param:Float y] )</h3>
+		<p>
+			Imposta i valori delle proprietà [page:.radius radius], [page:.theta theta]
+			e [page:.y y] di questo cilindro.
+		</p>
+
+		<h3>[method:this setFromVector3]( [param:Vector3 vec3] )</h3>
+		<p>
+			Imposta i valori delle proprietà [page:.radius radius], [page:.theta theta]
+			e [page:.y y] di questo cilindro dal [page:Vector3 Vector3].
+		</p>
+
+		<h3>[method:this setFromCartesianCoords]( [param:Float x], [param:Float y], [param:Float z] )</h3>
+		<p>
+			Imposta i valori delle proprietà [page:.radius radius], [page:.theta theta]
+			e [page:.y y] di questo cilindro dalle coordinate cartesiane.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Euler.html

@@ -0,0 +1,161 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una classe che rappresenta gli [link:http://en.wikipedia.org/wiki/Euler_angles angoli di Eulero].<br /><br />
+
+			Gli angoli di eulero descrivono una trasformazione rotazionale ruotando un oggetto sui suoi vari assi 
+			in quantità specifiche per asse, e in un ordine specificato per asse.
+		</p>
+
+		<p>
+			L'iterazione di un'istanza di [name] produce le sue componenti (x, y, z, order) nell'ordine corrispondente.
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>const a = new THREE.Euler( 0, 1, 1.57, 'XYZ' );
+		const b = new THREE.Vector3( 1, 0, 1 );
+		b.applyEuler(a);
+		</code>
+
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]( [param:Float x], [param:Float y], [param:Float z], [param:String order] )</h3>
+		<p>
+		[page:Float x] - (opzionale) l'angolo dell'asse x in radianti. Il valore predefinito è `0`.<br />
+		[page:Float y] - (opzionale) l'angolo dell'asse y in radianti. Il valore predefinito è `0`.<br />
+		[page:Float z] - (opzionale) l'angolo dell'asse z in radianti. Il valore predefinito è `0`.<br />
+		[page:String order] - (opzionale) una stringa che rappresenta l'ordine in cui vengono applicate le rotazioni,
+		il valore predefinito è 'XYZ' (deve essere in maiuscolo).<br /><br />
+
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Boolean isEuler]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h3>[property:String order]</h3>
+		<p>
+			L'ordine in cui applicare le rotazioni. Il valore predefinito è 'XYZ', questo significa che l'oggetto 
+			verrà ruotato prima intorno all'asse X, poi intorno all'asse Y e infine intorno all'asse Z. Altre possibilità sono:
+			'YZX', 'ZXY', 'XZY', 'YXZ' e 'ZYX'. Queste devono essere in maiuscolo.<br /><br />
+
+			Three.js utilizza gli angoli Tait-Bryan `intrinseci`. Questo significa che le rotazioni vengono eseguite 
+			rispettando il sistema di coordinate `locale`. Cioè per l'ordine 'XYZ', la rotazione verrà prima eseguita
+			intorno all'asse locale X (il che è lo stesso dell'asse world X), poi intorno all'asse locale Y (che può essere diversa dall'asse
+			world Y), ed infine intorno all'asse Z (che può essere diversa dall'asse world Z).
+		</p>
+
+		<h3>[property:Float x]</h3>
+		<p>
+			Il valore corrente del componente x.
+		</p>
+
+		<h3>[property:Float y]</h3>
+		<p>
+			Il valore corrente del componente y.
+		</p>
+
+		<h3>[property:Float z]</h3>
+		<p>
+			Il valore corrente del componente z.
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:this copy]( [param:Euler euler] )</h3>
+		<p>Copia il valore di [page:Euler Eulero] in questo Eulero.</p>
+
+		<h3>[method:Euler clone]()</h3>
+		<p>Restituisce un nuovo Eulero con gli stessi parametri di questo.</p>
+
+		<h3>[method:Boolean equals]( [param:Euler euler] )</h3>
+		<p>Verifica la stretta uguaglianza di questo Eulero ed [page:Euler Eulero].</p>
+
+		<h3>[method:this fromArray]( [param:Array array] )</h3>
+		<p>
+		[page:Array array] di lunghezza 3 o 4. Il quarto argomento, opzionale, corrisponde all'[page:.order order].<br /><br />
+
+		Assegna l'angolo [page:.x x] di questo Eulero a `array[0]`. <br />
+		Assegna l'angolo [page:.y y] di questo Eulero a `array[1]`. <br />
+		Assegna l'angolo [page:.z z] di questo Eulero a `array[2]`. <br />
+		Facoltativamente, assegna [page:.order order] di questo Eulero a `array[3]`.
+		</p>
+
+		<h3>[method:this reorder]( [param:String newOrder] )</h3>
+		<p>
+			Reimposta l'angolo di eulero con un nuovo ordine creando un quaternione da questo angolo di Eulero 
+			e quindi impostando questo angolo di Eulero con il quaternione ed il nuovo ordine.<br /><br />
+
+		<em>*Attenzione*: questo scarta le informazioni sulla rivoluzione.</em>
+		</p>
+
+		<h3>[method:this set]( [param:Float x], [param:Float y], [param:Float z], [param:String order] )</h3>
+		<p>
+			[page:.x x] - l'angolo dell'asse x in radianti.<br />
+			[page:.y y] - l'angolo dell'asse y in radianti.<br />
+			[page:.z z] - l'angolo dell'asse z in radianti.<br />
+			[page:.order order] - (opzionale) una stringa che rappresenta l'ordine in cui vengono applicate le rotazioni.<br /><br />
+
+			Imposta gli angoli di questa trasformazione di Eulero e, facoltativamente, l'[page:.order ordine].
+		</p>
+
+		<h3>[method:this setFromRotationMatrix]( [param:Matrix4 m], [param:String order] )</h3>
+		<p>
+		[page:Matrix4 m] - una [page:Matrix4] di cui la parte superiore 3x3 della matrice è una
+		[link:https://en.wikipedia.org/wiki/Rotation_matrix matrice di rotazione] pura (cioè non scalata).<br />
+		[page:.order order] - (opzionale) una stringa che rappresenta l'ordine in cui vengono applicate le rotazioni.<br />
+
+		Imposta gli angoli di questa trasformazione di Eulero da una matrice di rotazione pura in base 
+		all'orientamento specificato dall'[page:.order ordine].
+		</p>
+
+		<h3>[method:this setFromQuaternion]( [param:Quaternion q], [param:String order] )</h3>
+		<p>
+		[page:Quaternion q] - un quaternione normalizzato.<br />
+		[page:.order order] - (opzionale) una stringa che rappresenta l'ordine in cui vengono applicate le rotazioni.<br />
+
+		Imposta gli angoli di questa trasformazione di Eulero da un quaternione normalizzato in base all'orientamento
+		specificato dall'[page:.order ordine].
+		</p>
+
+
+		<h3>[method:this setFromVector3]( [param:Vector3 vector], [param:String order] )</h3>
+		<p>
+		[page:Vector3 vector] - [page:Vector3].<br />
+		[page:.order order] - (opzionale) una stringa che rappresenta l'ordine in cui vengono applicate le rotazioni.<br />
+
+		Imposta [page:.x x], [page:.y y] e [page:.z z], e facoltativamente aggiorna l'[page:.order ordine].
+		</p>
+
+
+		<h3>[method:Array toArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - (opzionale) un array per memorizzare l'Eulero.<br />
+		[page:Integer offset] - (opzionale) offset nell'array.<br />
+
+		Restituisce un array della forma [[page:.x x], [page:.y y], [page:.z z], [page:.order order]].
+	</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Frustum.html

@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Il [link:http://en.wikipedia.org/wiki/Frustum Frustum] viene utilizzato per determinare cosa c'è 
+			all'interno del campo visivo della telecamera. Aiuta ad accellerare il processo di rendering - 
+			gli oggetti che si trovano al di fuori del frustum della telecamera possono essere tranquillamente
+			esclusi dal rendering.<br /><br />
+
+			Questa classe è principalmente pensata per l'uso interno da parte di un renderer per il calcolo
+			di una [page:Camera telecamera] o dal frustum della [page:LightShadow.camera shadowCamera].
+		</p>
+
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]([param:Plane p0], [param:Plane p1], [param:Plane p2], [param:Plane p3], [param:Plane p4], [param:Plane p5])</h3>
+		<p>
+			[page:Plane p0] - (opzionale) impostato su un nuovo [page:Plane].<br />
+			[page:Plane p1] - (opzionale) impostato su un nuovo [page:Plane].<br />
+			[page:Plane p2] - (opzionale) impostato su un nuovo [page:Plane].<br />
+			[page:Plane p3] - (opzionale) impostato su un nuovo [page:Plane].<br />
+			[page:Plane p4] - (opzionale) impostato su un nuovo [page:Plane].<br />
+			[page:Plane p5] - (opzionale) impostato su un nuovo [page:Plane].<br /><br />
+
+			Crea un nuovo [name].
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Array planes]</h3>
+		<p>Array di 6 [page:Plane piani].</p>
+
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Frustum clone]()</h3>
+		<p>Restituisce un nuovo Frustum con gli stessi parametri di questo.</p>
+
+
+		<h3>[method:Boolean containsPoint]( [param:Vector3 point] )</h3>
+		<p>
+		[page:Vector3 point] - [page:Vector3] di test.<br /><br />
+
+		Verifica se il frustum contiene il [page:Vector3 punto].
+		</p>
+
+		<h3>[method:this copy]( [param:Frustum frustum] )</h3>
+		<p>
+		[page:Frustum frustum] - Il frustum da copiare<br /><br />
+
+		Copia le proprietà del [page:Frustum frustum] passato in questo.
+		</p>
+
+		<h3>[method:Boolean intersectsBox]( [param:Box3 box] )</h3>
+		<p>
+		[page:Box3 box] - [page:Box3] per verificare l'intersezione.<br /><br />
+
+		Restituisce true se il [page:Box3 box] si interseca con questo frustum.
+		</p>
+
+		<h3>[method:Boolean intersectsObject]( [param:Object3D object] )</h3>
+		<p>
+			Verifica se la [page:BufferGeometry.boundingSphere bounding sphere] dell'[page:Object3D oggetto] sta intersecando il frustum.<br /><br />
+
+			Si noti che l'oggetto deve avere una [page:BufferGeometry geometria] così che la bounding sphere possa essere calcolata.
+		</p>
+
+		<h3>[method:Boolean intersectsSphere]( [param:Sphere sphere] )</h3>
+		<p>
+		[page:Sphere sphere] - [page:Sphere] per verificare l'intersezione.<br /><br />
+
+		Restituisce true se la [page:Sphere sfera] si interseca con questo frustum.
+		</p>
+
+		<h3>[method:Boolean intersectsSprite]( [param:Sprite sprite] )</h3>
+		<p>
+			Verifica se la [page:Sprite sprite] si interseca con il frustum.
+		</p>
+
+		<h3>[method:this set]( [param:Plane p0], [param:Plane p1], [param:Plane p2], [param:Plane p3], [param:Plane p4], [param:Plane p5] )</h3>
+		<p>
+			Imposta il frustum dai piani passati. Nessun ordine dei piani è implicito.<br>
+			Si noti che questo metodo copia solo i valori degli oggetti dati.
+		</p>
+
+		<h3>[method:this setFromProjectionMatrix]( [param:Matrix4 matrix] )</h3>
+		<p>
+		[page:Matrix4 matrix] - La [page:Matrix4] di proiezione utilizzata per impostare i [page:.planes planes]<br /><br />
+
+		Imposta i piani del frustum dalla matrice di proiezione.
+		</p>
+
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Interpolant.html

@@ -0,0 +1,80 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Classe base astratta di interpolanti su campioni parametrici.<br /><br />
+
+			Il dominio del parametro è unidimensionale, tipicamente il tempo o un path lungo una curva definita dai dati.<br /><br />
+
+			I valori campione possono avere qualsiasi dimensionalità e le classi derivate possono applicare interpolazioni ai dati.<br /><br />
+
+			Questa classe fornisce l'intervallo di ricerca in un Metodo Modello, rinviando l'interpolazione effettiva alle classi derivate.<br /><br />
+
+			La complessità del tempo è `O(1)` per l'accesso lineare che attraversa al massimo due punti e `O(log N)` per l'accesso casuale,
+			dove *N* è il numero di posizioni.<br /><br />
+
+			Riferimenti:	[link:http://www.oodesign.com/template-method-pattern.html http://www.oodesign.com/template-method-pattern.html]
+		</p>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( parameterPositions, sampleValues, sampleSize, resultBuffer )</h3>
+		<p>
+		parameterPositions -- array di posizioni<br />
+		sampleValues -- array di campioni<br />
+		sampleSize -- numero di campioni<br />
+		resultBuffer -- buffer in cui memorizzare i risultati dell'interpolazione.<br /><br />
+
+		Nota: Questa classe non è pensata per essere chiamata direttamente.
+		</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:null parameterPositions]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null resultBuffer]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null sampleValues]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:Object settings]</h3>
+		<p>
+			Opzionale, struttura delle impostazioni e specifica della sottoclasse.
+		</p>
+
+		<h3>[property:null valueSize]</h3>
+		<p>
+
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Array evaluate]( [param:Number t] )</h3>
+		<p>
+			Valuta l'interpolazione in posizione *t*.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Line3.html

@@ -0,0 +1,118 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">Un segmento di linea geometrico rappresentato da un punto iniziale e uno finale.</p>
+
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]( [param:Vector3 start], [param:Vector3 end] )</h3>
+		<p>
+		[page:Vector3 start] - Inizio del segmento. Il valore predefinito è `(0, 0, 0)`.<br />
+		[page:Vector3 end] - Fine del segmento. Il valore predefinito è `(0, 0, 0)`.<br /><br />
+
+		Crea un nuovo [name].
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Vector3 start]</h3>
+		<p>[page:Vector3] che rappresenta il punto di inizio della linea.</p>
+
+		<h3>[property:Vector3 end]</h3>
+		<p>[page:Vector3] che rappresenta il punto di fine della linea.</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:this applyMatrix4]( [param:Matrix4 matrix] )</h3>
+		<p>Applica una matrice di trasformazione al segmento.</p>
+
+		<h3>[method:Vector3 at]( [param:Float t], [param:Vector3 target] )</h3>
+		<p>
+		[page:Float t] - Utilizza i valori 0-1 per restituire una posizione lungo il segmento. <br />
+		[page:Vector3 target] — il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Restituisce un vettore in una determinata posizione lungo la linea. Quando [page:Float t] = 0, restituisce il vettore iniziale,
+		e quando [page:Float t] = 1 restituisce il vettore finale.<br />
+		</p>
+
+		<h3>[method:Line3 clone]()</h3>
+		<p>Restituisce un nuovo [page:Line3] con gli stessi vettori [page:.start start] e [page:.end end] di questo.</p>
+
+		<h3>[method:Vector3 closestPointToPoint]( [param:Vector3 point], [param:Boolean clampToLine], [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 point] - restituisce il punto più vicino alla linea a questo punto.<br />
+		[page:Boolean clampToLine] - indica se bloccare o meno il valore restituito al segmento.<br />
+		[page:Vector3 target] - il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Restituisce il punto più vicino alla linea. Se [page:Boolean clampToLine] è true, allora il valore restituito verrà bloccato alla linea.
+		</p>
+
+		<h3>[method:Float closestPointToPointParameter]( [param:Vector3 point], [param:Boolean clampToLine] )</h3>
+		<p>
+		[page:Vector3 point] - il punto per il quale restituire un parametro punto.<br />
+		[page:Boolean clampToLine] - indica se bloccare o meno il risultato nell'intervallo `[0, 1]`.<br /><br />
+
+		Restituisce un parametro punto basato sul punto più vicino come proiettato sul segmento.
+		Se [page:Boolean clampToLine] è true, allora il valore restituito sarà tra 0 e 1.
+		</p>
+
+		<h3>[method:this copy]( [param:Line3 line] )</h3>
+		<p>Copia i vettori [page:.start start] e [page:.end end] della linea passati in questa linea.</p>
+
+		<h3>[method:Vector3 delta]( [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 target] - il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Restituisce il vettore delta del segmento (vettore [page:.end end] meno il vettore [page:.start start]).
+		</p>
+
+		<h3>[method:Float distance]()</h3>
+		<p>Restituisce la [link:https://en.wikipedia.org/wiki/Euclidean_distance distanza Euclidea] 
+			(distanza in linea retta) tra i punti [page:.start start] e [page:.end end] della linea.</p>
+
+		<h3>[method:Float distanceSq]()</h3>
+		<p>
+			Restituisce il quadrato della  [link:https://en.wikipedia.org/wiki/Euclidean_distance distanza Euclidea] 
+			(distanza in linea retta) tra i vettori [page:.start start] e [page:.end end] della linea.
+		</p>
+
+		<h3>[method:Boolean equals]( [param:Line3 line] )</h3>
+		<p>
+		[page:Line3 line]  - [page:Line3] da confrontare con questo.<br /><br />
+
+		Restituisce true se entrambi i punti [page:.start start] e [page:.end end] della linea sono uguali.
+		</p>
+
+		<h3>[method:Vector3 getCenter]( [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 target] — il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Restituisce il centro del segmento.
+		</p>
+
+		<h3>[method:this set]( [param:Vector3 start], [param:Vector3 end] )</h3>
+		<p>
+		[page:Vector3 start] - imposta il punto [page:.start start] della linea.<br />
+		[page:Vector3 end] - imposta il punto [page:.end end] della linea.<br /><br />
+
+		Imposta i valori start ed end copiando i vettori forniti.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/MathUtils.html

@@ -0,0 +1,161 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">Un oggetto con molte funzioni matematiche di utilità.</p>
+
+		<h2>Funzioni</h2>
+
+		<h3>[method:Float clamp]( [param:Float value], [param:Float min], [param:Float max] )</h3>
+		<p>
+		[page:Float value] — Valore che deve essere fissato.<br />
+		[page:Float min] — Valore minimo.<br />
+		[page:Float max] — Valore massimo.<br /><br />
+
+		Fissa il [page:Float value] tra il [page:Float min] e il [page:Float max].
+		</p>
+
+		<h3>[method:Float degToRad]( [param:Float degrees] )</h3>
+		<p>Converte i gradi in radianti.</p>
+
+		<h3>[method:Integer euclideanModulo]( [param:Integer n], [param:Integer m] )</h3>
+		<p>
+		[page:Integer n], [page:Integer m] - Interi<br /><br />
+
+		Calcola il modulo Euclideo di [page:Integer m] % [page:Integer n], che è:
+		<code>( ( n % m ) + m ) % m</code>
+		</p>
+
+		<h3>[method:UUID generateUUID]( )</h3>
+		<p>
+		Genera un'[link:https://en.wikipedia.org/wiki/Universally_unique_identifier UUID]
+		(universally unique identifier).
+		</p>
+
+		<h3>[method:Boolean isPowerOfTwo]( [param:Number n] )</h3>
+		<p>Restituisce `true` se [page:Number n] è una potenza di 2.</p>
+
+		<h3>[method:Float inverseLerp]( [param:Float x], [param:Float y], [param:Float value] )</h3>
+		<p>
+		[page:Float x] - Punto di inizio.<br />
+		[page:Float y] - Punto di fine.<br />
+		[page:Float value] - Un valore tra l'inizio e la fine.<br><br />
+
+		Restituisce la percentuale nell'intervallo chiuso `[0, 1]` del valore dato tra il punto di inizio e di fine.
+		</p>
+
+		<h3>[method:Float lerp]( [param:Float x], [param:Float y], [param:Float t] )</h3>
+		<p>
+		[page:Float x] - Punto di inizio. <br />
+		[page:Float y] - Punto di fine. <br />
+		[page:Float t] - Fattore di interpolazione nell'intervallo chiuso `[0, 1]`.<br><br />
+
+		Restituisce un valore [link:https://en.wikipedia.org/wiki/Linear_interpolation interpolato linearmente]
+		da due punti noti in base all'intervallo dato - [page:Float t] = 0 restituirà [page:Float x]
+		e [page:Float t] = 1 restituirà [page:Float y].
+		</p>
+
+		<h3>[method:Float damp]( [param:Float x], [param:Float y], [param:Float lambda], [param:Float dt] )</h3>
+		<p>
+		[page:Float x] - Punto corrente. <br />
+		[page:Float y] - Punto target. <br />
+		[page:Float lambda] - Un valore lambda più alto renderà il movimento più improvviso, e un valore più basso renderà il movimento più graduale. <br />
+		[page:Float dt] - Il tempo delta in secondi.<br><br />
+
+		Interpola in modo fluido un numero da [page:Float x] a [page:Float y] in modo simile ad una molla usando [page:Float dt]
+		per mantenere il movimento indipendente dalla frequenza dei fotogrammi. Per i dettagli, vedere 
+		[link:http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/ Smorzamento indipendente dalla frequenza dei fotogrammi mediante lerp].
+		</p>
+
+		<h3>[method:Float mapLinear]( [param:Float x], [param:Float a1], [param:Float a2], [param:Float b1], [param:Float b2] )</h3>
+		<p>
+		[page:Float x] — Valore da mappare.<br />
+		[page:Float a1] — Minimo valore per il range A.<br />
+		[page:Float a2] — Massimo valore per il range A.<br />
+		[page:Float b1] — Minimo valore per il range B.<br />
+		[page:Float b2] — Massimo valore per il range B.<br /><br />
+
+		Mappa lineare di [page:Float x] dall'intervallo [[page:Float a1], [page:Float a2]] all'intervallo [[page:Float b1], [page:Float b2]].
+		</p>
+
+		<h3>[method:Float pingpong]( [param:Float x], [param:Float length] )</h3>
+		<p>
+		[page:Float x] — Il valore del pingpong.<br />
+		[page:Float length] — Il valore positivo a cui la funzione farà pingpong. Il valore predefinito è 1.<br /><br />
+
+		Restituisce un valore che alterna tra 0 e [param:Float length].
+		</p>
+
+		<h3>[method:Integer ceilPowerOfTwo]( [param:Number n] )</h3>
+		<p>Restituisce la potenza di 2 più piccola, maggiore o uguale a [page:Number n].</p>
+
+		<h3>[method:Integer floorPowerOfTwo]( [param:Number n] )</h3>
+		<p>Restituisce la massima potenza di 2, minore o uguale a [page:Number n].</p>
+
+		<h3>[method:Float radToDeg]( [param:Float radians] )</h3>
+		<p>Coverte i radianti in gradi.</p>
+
+		<h3>[method:Float randFloat]( [param:Float low], [param:Float high] )</h3>
+		<p>Float casuale nell'intervallo [[page:Float low], [page:Float high]].</p>
+
+		<h3>[method:Float randFloatSpread]( [param:Float range] )</h3>
+		<p>Float casuale nell'intervallo [- [page:Float range] / 2, [page:Float range] / 2].</p>
+
+		<h3>[method:Integer randInt]( [param:Integer low], [param:Integer high] )</h3>
+		<p>Intero casuale nell'intervallo [[page:Float low], [page:Float high]].</p>
+
+		<h3>[method:Float seededRandom]( [param:Integer seed] )</h3>
+		<p>Float pseudocasuale deterministico nell'intervallo `[0, 1]`. L'intero [page:Integer seed] è opzionale.</p>
+
+		<h3>[method:Float smoothstep]( [param:Float x], [param:Float min], [param:Float max] )</h3>
+		<p>
+		[page:Float x] - Il valore da valutare in base alla sua posizione tra il min e il max. <br />
+		[page:Float min] - Qualsiasi valore di x sotto il min sarà 0.<br />
+		[page:Float max] - Qualsiasi valore di x sopra il max sarà 1.<br /><br />
+
+		Restituisce un valore compreso tra 0-1 che rappresenta la percentuale di spostamento di x tra il min e il max,
+		ma attenuata o rallentata quanto più X si avvicina al minimo e al massimo.<br/><br/>
+
+		Vedi [link:http://en.wikipedia.org/wiki/Smoothstep Smoothstep] per i dettagli.
+		</p>
+
+		<h3>[method:Float smootherstep]( [param:Float x], [param:Float min], [param:Float max] )</h3>
+		<p>
+		[page:Float x] - Il valore da valutare in base alla sua posizione tra il min e il max. <br />
+		[page:Float min] - Qualsiasi valore di x sotto il min sarà 0.<br />
+		[page:Float max] - Qualsiasi valore di x sopra il max sarà 1.<br /><br />
+
+		Restituisce un valore compreso tra 0-1. Una [link:https://en.wikipedia.org/wiki/Smoothstep#Variations variazione su smoothstep]
+		che ha zero derivare di primo e secondo ordine a x=0 e x=1.
+		</p>
+
+		<h3>[method:undefined setQuaternionFromProperEuler]( [param:Quaternion q], [param:Float a], [param:Float b], [param:Float c], [param:String order] )</h3>
+		<p>
+		[page:Quaternion q] - Il quaternione da impostare.<br />
+		[page:Float a] - La rotazione applicata al primo asse, in radianti.<br />
+		[page:Float b] - La rotazione applicata al secondo asse, in radianti.<br />
+		[page:Float c] - La rotazione applicata al terzo asse, in radianti.<br />
+		[page:String order] - una stringa che specifica l'ordine degli assi: 'XYX', 'XZX', 'YXY', 'YZY', 'ZXZ', o 'ZYZ'<br /><br />
+
+		Imposta il quaternione [page:Quaternion q] dagli [link:http://en.wikipedia.org/wiki/Euler_angles angoli di Eulero propri intrinseci] definiti 
+		dagli angoli [page:Float a], [page:Float b], e [page:Float c], e dall'ordine [page:String order].<br />
+
+		Le rotazioni vengono applicate agli assi nell'ordine specificato da [page:String order]:
+		la rotazione per l'angolo [page:Float a] viene applicata per prima, poi l'angolo [page:Float b], infine l'angolo [page:Float c].
+		Gli angoli sono in radianti.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Matrix3.html

@@ -0,0 +1,208 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una classe che rappresenta una [link:https://en.wikipedia.org/wiki/Matrix_(mathematics) matrice] 3x3.
+		</p>
+
+		<h2>Codice di Esempio</h2>
+		<code>
+const m = new Matrix3();
+		</code>
+
+		<h2>Una nota sull'ordine delle Row-Major (righe principali) e delle Column-Major (colonne principali)</h2>
+		<p>
+			Il metodo [page:set]() accetta gli argomenti in ordine 
+			[link:https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order row-major], mentre internamente 
+			vengono memorizzati nell'array [page:.elements elements] nell'ordine column-major.<br /><br />
+
+			Ciò significa che la chiamata a
+		<code>
+m.set( 11, 12, 13,
+       21, 22, 23,
+       31, 32, 33 );
+		</code>
+		risulterà nell'array [page:.elements elements] contenente:
+		<code>
+m.elements = [ 11, 21, 31,
+              12, 22, 32,
+              13, 23, 33 ];
+		</code>
+		e internamente tutti i calcoli vengono eseguiti utilizzando l'ordine column-major. Tuttavia, poiché l'ordine 
+		effettivo non fa alcune differenza matematicamente e la maggior parte delle persone è abituata a pensare alle
+		matrici nell'ordine row-major, la documentazione di three.js mostra le matrici in ordine di row-major.
+		Tieni solo a mente che se stai leggendo il codice sorgente, dovrai prendere la [link:https://en.wikipedia.org/wiki/Transpose trasposizione]
+		di tutte le matrici qui descritte per dare un senso ai calcoli.
+		</p>
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]()</h3>
+		<p>
+			Crea e inizializza [name] nella 
+			[link:https://en.wikipedia.org/wiki/Identity_matrix matrice] identità 3x3.
+		</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Array elements]</h3>
+		<p>
+			Una lista di [link:https://en.wikipedia.org/wiki/Row-_and_column-major_order column-major] 
+			di valori della matrice.
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Matrix3 clone]()</h3>
+		<p>Crea una Matrix3 con elementi identici a questa.</p>
+
+		<h3>[method:this copy]( [param:Matrix3 m] )</h3>
+		<p>Copia gli elementi della matrice [page:Matrix3 m] in questa matrice.</p>
+
+		<h3>[method:Float determinant]()</h3>
+		<p>
+			Calcola e restituisce il [link:https://en.wikipedia.org/wiki/Determinant determinante] di questa matrice.
+		</p>
+
+		<h3>[method:Boolean equals]( [param:Matrix3 m] )</h3>
+		<p>Restituisce true se questa matrice e [page:Matrix3 m] sono uguali.</p>
+
+		<h3>[method:this extractBasis]( [param:Vector3 xAxis], [param:Vector3 yAxis], [param:Vector3 zAxis] )</h3>
+		<p>
+			Estrae la [link:https://en.wikipedia.org/wiki/Basis_(linear_algebra) base] di questa matrice
+			nei tre vettori asse forniti. Se questa matrice è:
+		<code>
+a, b, c,
+d, e, f,
+g, h, i
+		</code>
+		allora [page:Vector3 xAxis], [page:Vector3 yAxis], [page:Vector3 zAxis] saranno impostate a:
+		<code>
+xAxis = (a, d, g)
+yAxis = (b, e, h)
+zAxis = (c, f, i)
+		</code>
+		</p>
+
+		<h3>[method:this fromArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - l'array da cui leggere gli elementi.<br />
+		[page:Integer offset] - (opzionale) indice del primo elemento nell'array. Il valore predefinito è 0.<br /><br />
+
+		Imposta gli elementi di questa matrice in base ad un array nel formato
+		[link:https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order column-major].
+		</p>
+
+		<h3>[method:this invert]()</h3>
+		<p>
+			Inverte questa matrice, utilizzando il [link:https://en.wikipedia.org/wiki/Invertible_matrix#Analytic_solution metodo analitico].
+
+			Non puoi invertire con un determinante zero. Se si tenta questo, il metodo produce invece una matrice zero.
+		</p>
+
+		<h3>[method:this getNormalMatrix]( [param:Matrix4 m] )</h3>
+		<p>
+		[page:Matrix4 m] - [page:Matrix4]<br /><br />
+
+		Imposta questa matrice come 3x3 in alto a sinistra della [link:https://en.wikipedia.org/wiki/Normal_matrix matrice normale]
+		della [page:Matrix4 matrix4] passata. La matrice normale è la [link:https://en.wikipedia.org/wiki/Transpose trasposta]
+		[link:https://en.wikipedia.org/wiki/Invertible_matrix inversa] della matrice [page:Matrix4 m].
+		</p>
+
+		<h3>[method:this identity]()</h3>
+		<p>
+			Reimposta questa matrice alla matrice identità 3x3:
+		<code>
+1, 0, 0
+0, 1, 0
+0, 0, 1
+		</code>
+
+		</p>
+
+		<h3>[method:this multiply]( [param:Matrix3 m] )</h3>
+		<p>Post-moltiplica questa matrice per [page:Matrix3 m].</p>
+
+		<h3>[method:this multiplyMatrices]( [param:Matrix3 a], [param:Matrix3 b] )</h3>
+		<p>Imposta questa matrice ad [page:Matrix3 a] x [page:Matrix3 b].</p>
+
+		<h3>[method:this multiplyScalar]( [param:Float s] )</h3>
+		<p>Moltiplica ogni componente della matrice per il valore scalare *s*.</p>
+
+		<h3>[method:this rotate]( [param:Float theta] )</h3>
+		<p>Ruota questa matrice dell'angolo dato (in radianti).</p>
+
+		<h3>[method:this scale]( [param:Float sx], [param:Float sy] )</h3>
+		<p>Ridimensiona questa matrice dei valori scalari passati.</p>
+
+		<h3>[method:this set]( [param:Float n11], [param:Float n12], [param:Float n13], [param:Float n21], [param:Float n22], [param:Float n23], [param:Float n31], [param:Float n32], [param:Float n33] )</h3>
+		<p>
+		[page:Float n11] - valore da inserire nella riga 1, colonna 1.<br />
+		[page:Float n12] - valore da inserire nella riga 1, colonna 2.<br />
+		...<br />
+		...<br />
+		[page:Float n32] - valore da inserire nella riga 3, colonna 2.<br />
+		[page:Float n33] - valore da inserire nella riga 3, colonna 3.<br /><br />
+
+		Imposta i valori della matrice 3x3 sulla sequenza di valori della
+		[link:https://en.wikipedia.org/wiki/Row-_and_column-major_order row-major] specificata.
+		</p>
+
+		<h3>[method:this premultiply]( [param:Matrix3 m] )</h3>
+		<p>Pre-moltiplica questa matrice per [page:Matrix3 m].</p>
+
+		<h3>[method:this setFromMatrix4]( [param:Matrix4 m] )</h3>
+		<p>Imposta questa matrice sulla matrice 3x3 superiore di Matrix4 [page:Matrix4 m].</p>
+
+		<h3>[method:this setUvTransform]( [param:Float tx], [param:Float ty], [param:Float sx], [param:Float sy], [param:Float rotation], [param:Float cx], [param:Float cy] )</h3>
+		<p>
+		[page:Float tx] - offset x<br />
+		[page:Float ty] - offset y<br />
+		[page:Float sx] - repeat x<br />
+		[page:Float sy] - repeat y<br />
+		[page:Float rotation] - rotazione (in radianti)<br />
+		[page:Float cx] - centro x di rotazione<br />
+		[page:Float cy] - centro y di rotazione<br /><br />
+
+		Imposta la matrice di trasformazione UV da offset, ripetizione, rotazione e centro.
+		</p>
+
+		<h3>[method:Array toArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - (opzionale) array per memorizzare il vettore risultante. In caso contrario, verrà creato un nuovo array.<br />
+		[page:Integer offset] - (opzionale) offset nell'array in cui inserire il risultato.<br /><br />
+
+		Scrive gli elementi di questa matrice in una matrice in formato 
+		[link:https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order column-major].
+		</p>
+
+		<h3>[method:this translate]( [param:Float tx], [param:Float ty] )</h3>
+		<p>Trasla questa matrice dei valori scalari dati.</p>
+
+		<h3>[method:this transpose]()</h3>
+		<p>[link:https://en.wikipedia.org/wiki/Transpose Traspone] questa matrice al suo posto.</p>
+
+		<h3>[method:this transposeIntoArray]( [param:Array array] )</h3>
+		<p>
+		[page:Array array] - array per memorizzare il vettore risultante.<br /><br />
+
+		[link:https://en.wikipedia.org/wiki/Transpose Traspone] questa matrice nell'array fornito,
+		e ritorna immutato.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Matrix4.html

@@ -0,0 +1,418 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una classe che rappresenta una [link:https://en.wikipedia.org/wiki/Matrix_(mathematics) matrice] 4x4.<br /><br />
+
+			L'uso più comune di una matrice 4x4 nella grafica 3D è come una 
+			[link:https://en.wikipedia.org/wiki/Transformation_matrix matrice di trasformazione].
+			
+			Per un'introduzione alle matrici di trasformazione utilizzate in WebGL, 
+			dai un'occhiata a [link:http://www.opengl-tutorial.org/beginners-tutorials/tutorial-3-matrices questo tutorial].<br /><br />
+
+			Ciò consente ad un [page:Vector3] che rappresenta un punto nello spazio 3D di subire trasformazioni come traslazione, rotazione
+			taglio, scala, riflessione, proiezione ortogonale o prospettica e così via, moltiplicandosi per la matrice.
+			Questo è noto come `applicare` la matrice al vettore.<br /><br />
+
+			Ogni [page:Object3D] ha tre Matrix4 associate:
+			<ul>
+				<li>
+					[page:Object3D.matrix]: Questo memorizza la trasfomazione locale dell'oggetto. Questa è la trasformazione dell'oggetto rispetto al suo genitore.
+				</li>
+				<li>
+					[page:Object3D.matrixWorld]: La trasformazione globale o world dell'oggetto. Se l'oggetto non ha un genitore, allora questo è identico 
+					alla trasformazione locale memorizzata nella [page:Object3D.matrix matrix].
+				</li>
+				<li>
+					[page:Object3D.modelViewMatrix]: Questo rappresenta la trasformazione dell'oggetto rispetto al sistema di coordinate della telecamera.
+					Il modelViewMatrix dell'oggetto è il matrixWorld dell'oggetto pre-moltiplicato per il matrixWorldInverse della telecamera.
+				</li>
+			</ul>
+
+			Le [page:Camera Telecamere] hanno tre Matrix4 addizionali:
+			<ul>
+				<li>
+					[page:Camera.matrixWorldInverse]: La matrice di visualizzazione - l'inversa della [page:Object3D.matrixWorld matrixWorld] della telecamera.
+				</li>
+				<li>
+					[page:Camera.projectionMatrix]: Rappresenta le informazioni su come proiettare la scena nello spazio di ritaglio.
+				</li>
+				<li>
+					[page:Camera.projectionMatrixInverse]: L'inverso della projectionMatrix.
+				</li>
+			</ul>
+			Nota: [page:Object3D.normalMatrix] non è una Matrix4, ma una [page:Matrix3].
+		</p>
+
+		<h2>Una nota sull'ordine delle Row-Major (righe principali) e delle Column-Major (colonne principali)</h2>
+		<p>
+			Il metodo [page:set]() accetta gli argomenti in ordine 
+			[link:https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order row-major], mentre internamente 
+			vengono memorizzati nell'array [page:.elements elements] nell'ordine column-major.<br /><br />
+
+			Ciò significa che la chiamata a
+		<code>
+const m = new THREE.Matrix4();
+
+m.set( 11, 12, 13, 14,
+       21, 22, 23, 24,
+       31, 32, 33, 34,
+       41, 42, 43, 44 );
+
+		</code>
+		risulterà nell'array [page:.elements elements] contenente:
+		<code>
+m.elements = [ 11, 21, 31, 41,
+               12, 22, 32, 42,
+               13, 23, 33, 43,
+               14, 24, 34, 44 ];
+		</code>
+		e internamente tutti i calcoli vengono eseguiti utilizzando l'ordine column-major. Tuttavia, poiché l'ordine 
+		effettivo non fa alcune differenza matematicamente e la maggior parte delle persone è abituata a pensare alle
+		matrici nell'ordine row-major, la documentazione di three.js mostra le matrici in ordine di row-major.
+		Tieni solo a mente che se stai leggendo il codice sorgente, dovrai prendere la [link:https://en.wikipedia.org/wiki/Transpose trasposizione]
+		di tutte le matrici qui descritte per dare un senso ai calcoli.
+		</p>
+
+		<h2>Estrazione della posizione, della rotazione e del ridimensionamento</h2>
+		<p>
+			Ci sono molte opzioni disponibili per l'estrazione della posizione, della rotazione e del ridimensionamento da una Matrix4.
+			<ul>
+				<li>
+					[page:Vector3.setFromMatrixPosition]: può essere utilizzato per estrarre il componente traslazione.
+				</li>
+				<li>
+					[page:Vector3.setFromMatrixScale]: può essere utilizzato per estrarre il componente ridimensionamento.
+				</li>
+				<li>
+					[page:Quaternion.setFromRotationMatrix], [page:Euler.setFromRotationMatrix] o [page:.extractRotation extractRotation] 
+					può essere utilizzato per estrarre il componente rotazione da una matrice pura (non ridimensionata).
+				</li>
+				<li>
+					[page:.decompose decompose] può essere utilizzato per estrarre la posizione, la rotazione e il ridemsionamento tutti in uno.
+				</li>
+			</ul>
+		</p>
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]()</h3>
+
+		<p>
+			Crea e inizializza [name] nella [link:https://en.wikipedia.org/wiki/Identity_matrix matrice] identità 4x4.
+	</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Array elements]</h3>
+		<p>
+			Una lista di [link:https://en.wikipedia.org/wiki/Row-_and_column-major_order column-major] 
+			di valori della matrice.
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Matrix4 clone]()</h3>
+		<p>Crea una nuova Matrix4 con gli [page:.elements elementi] identici a questa.</p>
+
+		<h3>[method:this compose]( [param:Vector3 position], [param:Quaternion quaternion], [param:Vector3 scale] )</h3>
+		<p>
+			Imposta questa matrice sulla trasformazione composta da [page:Vector3 posizione],
+			[page:Quaternion quaternione] e [page:Vector3 ridimensionamento].
+		</p>
+
+		<h3>[method:this copy]( [param:Matrix4 m] )</h3>
+		<p>Copia gli [page:.elements elementi] della matrice [page:Matrix4 m] in questa matrice.</p>
+
+		<h3>[method:this copyPosition]( [param:Matrix4 m] )</h3>
+		<p>
+			Copia il componente traslazione della matrice [page:Matrix4 m] fornita nel componente
+			trasformazione di questa matrice.
+		</p>
+
+		<h3>[method:this decompose]( [param:Vector3 position], [param:Quaternion quaternion], [param:Vector3 scale] )</h3>
+		<p>
+			Decompone questa matrice nei suoi componenti [page:Vector3 posizione], [page:Quaternion quaternione] e [page:Vector3 ridimensionamento].<br/><br/>
+			Nota: Non tutte le matrici si possono scomporre in questo modo. Per esempio, se un oggetto ha un genitore ridimensionato non uniformemente,
+			allora la matrice del mondo dell'oggetto potrebbe non essere scomponibile e questo metodo potrebbe non essere appropriato.
+		</p>
+
+		<h3>[method:Float determinant]()</h3>
+		<p>
+			Calcola e restituisce il 
+		[link:https://en.wikipedia.org/wiki/Determinant determinante] di questa matrice.<br /><br />
+
+		Sulla base del metodo [link:http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm qui] descritto.
+		</p>
+
+		<h3>[method:Boolean equals]( [param:Matrix4 m] )</h3>
+		<p>Restituisce true se questa matrice e [page:Matrix4 m] sono uguali.</p>
+
+		<h3>[method:this extractBasis]( [param:Vector3 xAxis], [param:Vector3 yAxis], [param:Vector3 zAxis] )</h3>
+		<p>
+			Estrae la [link:https://en.wikipedia.org/wiki/Basis_(linear_algebra) base] di questa matrice
+			nei tre vettori asse forniti. Se questa matrice è:
+		<code>
+a, b, c, d,
+e, f, g, h,
+i, j, k, l,
+m, n, o, p
+		</code>
+		allora [page:Vector3 xAxis], [page:Vector3 yAxis], [page:Vector3 zAxis] saranno impostate a:
+		<code>
+xAxis = (a, e, i)
+yAxis = (b, f, j)
+zAxis = (c, g, k)
+		</code>
+		</p>
+
+		<h3>[method:this extractRotation]( [param:Matrix4 m] )</h3>
+		<p>
+			Estrae il componente rotazione della matrice [page:Matrix4 m] fornita nel componente rotazione di questa matrice.
+		</p>
+
+		<h3>[method:this fromArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - l'array da cui leggere gli elementi.<br />
+		[page:Integer offset] - (opzionale) indice del primo elemento nell'array. Il valore predefinito è 0.<br /><br />
+
+		Imposta gli elementi di questa matrice in base ad un array nel formato
+		[link:https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order column-major].
+		</p>
+
+		<h3>[method:this invert]()</h3>
+		<p>
+			Inverte questa matrice, utilizzando il [link:https://en.wikipedia.org/wiki/Invertible_matrix#Analytic_solution metodo analitico].
+
+			Non puoi invertire con un determinante zero. Se si tenta questo, il metodo produce invece una matrice zero.
+		</p>
+
+		<h3>[method:Float getMaxScaleOnAxis]()</h3>
+		<p>Ottiene il valore di ridimensionamento massimo dei 3 assi.</p>
+
+		<h3>[method:this identity]()</h3>
+		<p>Reimposta questa matrice alla [link:https://en.wikipedia.org/wiki/Identity_matrix matrice] identità.</p>
+
+		<h3>[method:this lookAt]( [param:Vector3 eye], [param:Vector3 target], [param:Vector3 up] )</h3>
+		<p>
+			Costruisce una matrice di rotazione, guardando dall'[page:Vector3 occhio] verso il [page:Vector3 target] orientato dal
+			vettore verso l'[page:Vector3 alto].
+		</p>
+
+		<h3>[method:this makeRotationAxis]( [param:Vector3 axis], [param:Float theta] )</h3>
+		<p>
+		[page:Vector3 axis] — Asse di rotazione, deve essere normalizzata.<br />
+		[page:Float theta] — Angolo di rotazione in radianti.<br /><br />
+
+		Imposta questa matrice come trasformazione di rotazione attorno all'[page:Vector3 asse] di [page:Float theta] radianti.<br />
+
+		Questa è un'alternativa alquanto controversa ma matematicamente valida alla rotazione tramite [page:Quaternion Quaternions].
+		Vedi la discussione [link:https://www.gamedev.net/articles/programming/math-and-physics/do-we-really-need-quaternions-r1199 qui].
+		</p>
+
+		<h3>[method:this makeBasis]( [param:Vector3 xAxis], [param:Vector3 yAxis], [param:Vector3 zAxis] )</h3>
+		<p>
+			Imposta questo sulla matrice di [link:https://en.wikipedia.org/wiki/Basis_(linear_algebra) base] composta dai tre
+			vettori di base forniti:
+		<code>
+xAxis.x, yAxis.x, zAxis.x, 0,
+xAxis.y, yAxis.y, zAxis.y, 0,
+xAxis.z, yAxis.z, zAxis.z, 0,
+0,       0,       0,       1
+		</code>
+		</p>
+
+		<h3>[method:this makePerspective]( [param:Float left], [param:Float right], [param:Float top], [param:Float bottom], [param:Float near], [param:Float far] )</h3>
+		<p>
+			Crea una matrice di [link:https://en.wikipedia.org/wiki/3D_projection#Perspective_projection proiezione prospettica].
+			Questa è utilizzata internamente da [page:PerspectiveCamera.updateProjectionMatrix]().
+		</p>
+
+		<h3>[method:this makeOrthographic]( [param:Float left], [param:Float right], [param:Float top], [param:Float bottom], [param:Float near], [param:Float far] )</h3>
+		<p>
+			Crea una matrice di [link:https://en.wikipedia.org/wiki/Orthographic_projection proiezione ortografica].
+			Questa è utilizzata internamente da [page:OrthographicCamera.updateProjectionMatrix]().
+		</p>
+
+		<h3>[method:this makeRotationFromEuler]( [param:Euler euler] )</h3>
+		<p>
+			Imposta il componente rotazione (la matrice 3x3 in alto a sinistra) di questa matrice sulla rotazione specificata dal dato [page:Euler Angolo di Eulero].
+			Il resto della matrice è impostato sull'identità. A seconda dell'[page:Euler.order ordine] di [page:Euler Eulero], ci sono sei possibili esisti.
+			Vedi [link:https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix questa pagina] per una lista completa.
+		</p>
+
+		<h3>[method:this makeRotationFromQuaternion]( [param:Quaternion q] )</h3>
+		<p>
+			Imposta il componente rotazinoe di questa matrice alla rotazione specificata da [page:Quaternion q], come 
+			descritto [link:https://en.wikipedia.org/wiki/Rotation_matrix#Quaternion qui].
+			Il resto della matrice è impostato all'identità. Quindi, dato [page:Quaternion q] = w + xi + yj + zk, la matrice risultante sarà:
+		<code>
+1-2y²-2z²    2xy-2zw    2xz+2yw    0
+2xy+2zw      1-2x²-2z²  2yz-2xw    0
+2xz-2yw      2yz+2xw    1-2x²-2y²  0
+0            0          0          1
+		</code>
+		</p>
+
+		<h3>[method:this makeRotationX]( [param:Float theta] )</h3>
+		<p>
+		[page:Float theta] — Angolo rotazione in radianti.<br /><br />
+
+		Imposta questa matrice come una trasformazione rotazionale attorno all'asse X in radianti theta [page:Float theta] (&theta;).
+		La matrice risultante sarà:
+		<code>
+1 0      0        0
+0 cos(&theta;) -sin(&theta;)  0
+0 sin(&theta;) cos(&theta;)   0
+0 0      0        1
+		</code>
+		</p>
+
+		<h3>[method:this makeRotationY]( [param:Float theta] )</h3>
+		<p>
+		[page:Float theta] — Angolo rotazione in radianti.<br /><br />
+
+		Imposta questa matrice come una trasformazione rotazionale attorno all'asse Y in radianti theta [page:Float theta] (&theta;).
+		La matrice risultante sarà:
+		<code>
+cos(&theta;)  0 sin(&theta;) 0
+0       1 0      0
+-sin(&theta;) 0 cos(&theta;) 0
+0       0 0      1
+		</code>
+		</p>
+
+		<h3>[method:this makeRotationZ]( [param:Float theta] )</h3>
+		<p>
+		[page:Float theta] — Angolo rotazione in radianti.<br /><br />
+
+		Imposta questa matrice come una trasformazione rotazionale attorno all'asse Z in radianti theta [page:Float theta] (&theta;).
+		La matrice risultante sarà:
+		<code>
+cos(&theta;) -sin(&theta;) 0 0
+sin(&theta;) cos(&theta;)  0 0
+0      0       1 0
+0      0       0 1
+		</code>
+		</p>
+
+		<h3>[method:this makeScale]( [param:Float x], [param:Float y], [param:Float z] )</h3>
+		<p>
+			[page:Float x] - la quantità da scalare sull'asse X.<br />
+			[page:Float y] - la quantità da scalare sull'asse Y.<br />
+			[page:Float z] - la quantità da scalare sull'asse Z.<br /><br />
+
+			Imposta questa matrice come trasformazione di scala:
+			<code>
+x, 0, 0, 0,
+0, y, 0, 0,
+0, 0, z, 0,
+0, 0, 0, 1
+			</code>
+		</p>
+
+		<h3>[method:this makeShear]( [param:Float xy], [param:Float xz], [param:Float yx], [param:Float yz], [param:Float zx], [param:Float zy] )</h3>
+		<p>
+			[page:Float xy] - la quantità di taglio di X per Y.<br />
+			[page:Float xz] - la quantità di taglio di X per Z.<br />
+			[page:Float yx] - la quantità di taglio di Y per X.<br />
+			[page:Float yz] - la quantità di taglio di Y per Z.<br />
+			[page:Float zx] - la quantità di taglio di Z per X.<br />
+			[page:Float zy] - la quantità di taglio di Z per Y.<br /><br />
+
+			Imposta questa matrice come trasformata di taglio:
+<code>
+1,   yx,  zx,  0,
+xy,   1,  zy,  0,
+xz,  yz,   1,  0,
+0,    0,   0,  1
+</code>
+		</p>
+
+		<h3>[method:this makeTranslation]( [param:Float x], [param:Float y], [param:Float z] )</h3>
+		<p>
+			[page:Float x] - la quantità da translare sull'asse X.<br />
+			[page:Float y] - la quantità da translare sull'asse Y.<br />
+			[page:Float z] - la quantità da translare sull'asse Z.<br /><br />
+
+			Imposta questa matrice come una trasformata di traslazione:
+		<code>
+1, 0, 0, x,
+0, 1, 0, y,
+0, 0, 1, z,
+0, 0, 0, 1
+		</code>
+		</p>
+
+		<h3>[method:this multiply]( [param:Matrix4 m] )</h3>
+		<p>Post-moltiplica questa matrice per [page:Matrix4 m].</p>
+
+		<h3>[method:this multiplyMatrices]( [param:Matrix4 a], [param:Matrix4 b] )</h3>
+		<p>Imposta questa matrice a [page:Matrix4 a] x [page:Matrix4 b].</p>
+
+		<h3>[method:this multiplyScalar]( [param:Float s] )</h3>
+		<p>Moltiplica ogni componente della matrice per il valore scalare [page:Float s].</p>
+
+		<h3>[method:this premultiply]( [param:Matrix4 m] )</h3>
+		<p>Pre-moltiplica questa matrice per [page:Matrix4 m].</p>
+
+		<h3>[method:this scale]( [param:Vector3 v] )</h3>
+		<p>Moltiplica le colonne di questa matrice per il vettore [page:Vector3 v].</p>
+
+		<h3>[method:this set]( [param:Float n11], [param:Float n12], [param:Float n13], [param:Float n14], [param:Float n21], [param:Float n22], [param:Float n23], [param:Float n24], [param:Float n31], [param:Float n32], [param:Float n33], [param:Float n34], [param:Float n41], [param:Float n42], [param:Float n43], [param:Float n44] )</h3>
+		<p>
+			Imposta gli [page:.elements elementi] di questa matrice ai valori principali di row-major forniti [page:Float n11],
+			[page:Float n12], ... [page:Float n44].
+		</p>
+
+		<h3>[method:this setFromMatrix3]( [param:Matrix3 m] )</h3>
+		<p>Imposta gli elementi 3x3 superiori di questa matrice sui valori di Matrix3 [page:Matrix3 m].</p>
+
+		<h3>[method:this setPosition]( [param:Vector3 v] )</h3>
+		<h3>[method:this setPosition]( [param:Float x], [param:Float y], [param:Float z] ) // optional API</h3>
+		<p>
+			Imposta la componente posizione per questa matrice dal vettore [page:Vector3 v], senza influenzare 
+			il resto della matrice - ovvero se la matrice è attulmente:
+<code>
+a, b, c, d,
+e, f, g, h,
+i, j, k, l,
+m, n, o, p
+</code>
+Questa diventa:
+<code>
+a, b, c, v.x,
+e, f, g, v.y,
+i, j, k, v.z,
+m, n, o, p
+</code>
+		</p>
+
+		<h3>[method:Array toArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - (opzionale) array per memorizzare il vettore risultante.<br />
+		[page:Integer offset] - (opzionale) offset nell'array in cui inserire il risultato.<br /><br />
+		
+		Scrive gli elementi di questa matrice in una matrice in formato 
+		[link:https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order column-major].
+		</p>
+
+		<h3>[method:this transpose]()</h3>
+		<p>[link:https://en.wikipedia.org/wiki/Transpose Traspone] questa matrice.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Plane.html

@@ -0,0 +1,181 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una superficie bidimensionale che si estende all'infinito nello spazio 3D, 
+			rappresentata in [link:http://mathworld.wolfram.com/HessianNormalForm.html forma normale Hessiana]
+			da un vettore normale di lunghezza unitaria e una costante.
+		</p>
+
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]( [param:Vector3 normal], [param:Float constant] )</h3>
+		<p>
+		[page:Vector3 normal] - (opzionale) un [page:Vector3] di lunghezza unitaria che definisce la normale del piano. Il valore predefinito è *(1, 0, 0)*.<br />
+		[page:Float constant] - (opzionale) la distanza con segno dall'origine al piano. Il valore predefinito è `0`.
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Boolean isPlane]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h3>[property:Vector3 normal]</h3>
+
+		<h3>[property:Float constant]</h3>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:this applyMatrix4]( [param:Matrix4 matrix], [param:Matrix3 optionalNormalMatrix] )</h3>
+		<p>
+		[page:Matrix4 matrix] - la [Page:Matrix4] da applicare.<br />
+		[page:Matrix3 optionalNormalMatrix] - (opzionale) [Page:Matrix3] normale pre-calcolata della Matrix4 da applicare.<br /><br />
+
+		Applica una Matrix4 al piano. La matrice deve essere una trasformata affine e omogenea.<br />
+		Se si fornisce una [page:Matrix3 optionalNormalMatrix], può essere creata in questo modo:
+		<code>
+		const optionalNormalMatrix = new THREE.Matrix3().getNormalMatrix( matrix );
+		</code>
+		</p>
+
+		<h3>[method:Plane clone]()</h3>
+		<p>Restituisce un nuovo piano con la stessa [page:.normal normal] e [page:.constant constant] di questo piano.</p>
+
+		<h3>[method:Vector3 coplanarPoint]( [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 target] — il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Restituisce un [page:Vector3] complanare al piano, calcolando la proiezione del vettore normale all'origine sul piano.
+		</p>
+
+		<h3>[method:this copy]( [param:Plane plane] )</h3>
+		<p>
+			Copia i valori delle proprietà [page:.normal normal] e [page:.constant constant] del piano passato in questo piano.
+		</p>
+
+		<h3>[method:Float distanceToPoint]( [param:Vector3 point] )</h3>
+		<p>Restituisce la distanza con segno dal [page:Vector3 point] al piano.</p>
+
+		<h3>[method:Float distanceToSphere]( [param:Sphere sphere] )</h3>
+		<p>Restituisce la distanza con segno dalla [page:Sphere sphere] al piano.</p>
+
+		<h3>[method:Boolean equals]( [param:Plane plane] )</h3>
+		<p>
+			Controlla se due piani sono uguali (le loro proprietà [page:.normal normal] e
+			[page:.constant constant] coincidono).
+		</p>
+
+		<h3>[method:Vector3 intersectLine]( [param:Line3 line], [param:Vector3 target] )</h3>
+		<p>
+		[page:Line3 line] - [page:Line3] per verificare l'intersezione.<br />
+		[page:Vector3 target] — il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Restituisce il punto di intersezione tra la linea passata e il piano. Restituisce `null`
+		se la linea non interseca il piano. Restituisce il punto di partenza della linea se la 
+		linea è complanare al piano.
+		</p>
+
+		<h3>[method:Boolean intersectsBox]( [param:Box3 box] )</h3>
+		<p>
+		[page:Box3 box] - il [page:Box3] per verificare l'intersezione.<br /><br />
+
+		Determina se questo piano interseca il [page:Box3 box] o no.
+		</p>
+
+		<h3>[method:Boolean intersectsLine]( [param:Line3 line] )</h3>
+		<p>
+		[page:Line3 line] - la [page:Line3] per verificare l'intersezione.<br /><br />
+
+		Verifica se un segmento di linea si interseca (passa attraverso) il piano o no.
+		</p>
+
+		<h3>[method:Boolean intersectsSphere]( [param:Sphere sphere] )</h3>
+		<p>
+		[page:Sphere sphere]  - la [page:Sphere] per verificare l'intersezione.<br /><br />
+
+		Determina se questo piano interseca la [page:Sphere sphere] o no.
+		</p>
+
+		<h3>[method:this negate]()</h3>
+		<p>
+			Nega sia la normale che la costante.
+		</p>
+
+		<h3>[method:this normalize]()</h3>
+		<p>
+			Normalizza il vettore [page:.normal normal], e aggiusta di conseguenza il valore della 
+			[page:.constant constant].
+		</p>
+
+		<h3>[method:Vector3 projectPoint]( [param:Vector3 point], [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 point] - il [page:Vector3] da proiettare sul piano.<br />
+		[page:Vector3 target] — il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Proietta un [page:Vector3 point] sul piano.
+		</p>
+
+		<h3>[method:this set]( [param:Vector3 normal], [param:Float constant] )</h3>
+		<p>
+			[page:Vector3 normal] - un [page:Vector3] di lunghezza unitaria che definisce la normale del piano.<br />
+			[page:Float constant] - la distanza con segno dall'origine al piano. Il valore predefinito è `0`.<br /><br />
+
+			Imposta le proprietà [page:.normal normal] e [page:.constant constant] del piano copiando i valori dalla normale data.
+		</p>
+
+		<h3>[method:this setComponents]( [param:Float x], [param:Float y], [param:Float z], [param:Float w] )</h3>
+		<p>
+		[page:Float x] - x valore del vettore normale di lunghezza unitaria.<br />
+		[page:Float y] - y valore del vettore normale di lunghezza unitaria.<br />
+		[page:Float z] - z valore del vettore normale di lunghezza unitaria.<br />
+		[page:Float w] - il valore della proprieà [page:.constant constant] del piano.<br /><br />
+
+		Imposta i singoli componenti che definiscono il piano.
+		</p>
+
+		<h3>[method:this setFromCoplanarPoints]( [param:Vector3 a], [param:Vector3 b], [param:Vector3 c] )</h3>
+		<p>
+		 [page:Vector3 a] - primo punto sul piano.<br />
+		 [page:Vector3 b] - secondo punto sul piano.<br />
+		 [page:Vector3 c] - terzo punto sul piano.<br /><br />
+
+		 Definisce il piano in base ai 3 punti forniti. Si presume che l'ordine di avvolgimento sia in senso antiorario,
+		 e determina la direzione della [page:.normal normale].
+		</p>
+
+		<h3>[method:this setFromNormalAndCoplanarPoint]( [param:Vector3 normal], [param:Vector3 point] )</h3>
+		<p>
+		[page:Vector3 normal] - un [page:Vector3] di lunghezza unitaria che definisce la normale del piano.<br />
+		[page:Vector3 point] - [page:Vector3]<br /><br />
+
+		Imposta le proprietà del piano definite da una [page:Vector3 normale] e un [page:Vector3 punto] complanare arbitrario.
+		</p>
+
+		<h3>[method:this translate]( [param:Vector3 offset] )</h3>
+		<p>
+		[page:Vector3 offset] - la quantità di cui muovere il piano.<br /><br />
+
+		Trasla il piano della distanza definita dal vettore [page:Vector3 offset].
+		Si noti che questo influisce solo la costante del piano e non influenzerà il vettore normale.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Quaternion.html

@@ -0,0 +1,264 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Implementazione di un [link:http://en.wikipedia.org/wiki/Quaternion quaternione].<br/>
+			I quaternioni sono utilizzati in three.js per rappresentare le [link:https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation rotazioni].
+		</p>
+
+		<p>
+			L'iterazione di un'istanza di [name] produrrà le sue componenti (x, y, z, w) nell'ordine corrispondente.
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const quaternion = new THREE.Quaternion();
+		quaternion.setFromAxisAngle( new THREE.Vector3( 0, 1, 0 ), Math.PI / 2 );
+
+		const vector = new THREE.Vector3( 1, 0, 0 );
+		vector.applyQuaternion( quaternion );
+		</code>
+
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]( [param:Float x], [param:Float y], [param:Float z], [param:Float w] )</h3>
+		<p>
+		[page:Float x] - coordinata x.<br />
+		[page:Float y] - coordinata y.<br />
+		[page:Float z] - coordinata z.<br />
+		[page:Float w] - coordinata w.
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Boolean isQuaternion]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h3>[property:Float x]</h3>
+
+		<h3>[property:Float y]</h3>
+
+		<h3>[property:Float z]</h3>
+
+		<h3>[property:Float w]</h3>
+
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Float angleTo]( [param:Quaternion q] )</h3>
+		<p>
+			Restituisce l'angolo tra questo quaternione e il quaternione [page:Quaternion q] in radianti. 
+		</p>
+
+		<h3>[method:Quaternion clone]()</h3>
+		<p>
+			Crea un nuovo [name] con le proprietà [page:.x x], [page:.y y],
+			[page:.z z] e [page:.w w] identiche a questo.
+		</p>
+
+		<h3>[method:this conjugate]()</h3>
+		<p>
+			Restituisce il coniugato rotazionale di questo quaternione. Il coniugato di un quaternione
+			rappresenta la stessa rotazione nella direzione opposta rispetto all'asse di rotazione.
+		</p>
+
+		<h3>[method:this copy]( [param:Quaternion q] )</h3>
+		<p>
+			Copia le proprietà [page:.x x], [page:.y y], [page:.z z] e [page:.w w] di 
+			[page:Quaternion q] in questo quaterione.
+		</p>
+
+		<h3>[method:Boolean equals]( [param:Quaternion v] )</h3>
+		<p>
+		[page:Quaternion v] - Quaterione a cui verrà paragonato questo quaternione.<br /><br />
+
+		Compara le proprietà [page:.x x], [page:.y y],	[page:.z z] and [page:.w w] di
+		[page:Quaternion v] alle proprietà equivalenti di questo quaternione per determinare 
+		se rappresentano la stessa rotazione.
+		</p>
+
+		<h3>[method:Float dot]( [param:Quaternion v] )</h3>
+		<p>
+			Calcola il [link:https://en.wikipedia.org/wiki/Dot_product prodotto scalare] dei
+			quaternioni [page:Quaternion v] e questo.
+		</p>
+
+		<h3>[method:this fromArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - array di formato (x, y, z, w) utilizzato per costruire il quaternione.<br />
+		[page:Integer offset] - (opzionale) un offset nell'array.<br /><br />
+
+		Imposta le proprietà [page:.x x], [page:.y y], [page:.z z] e [page:.w w] di questo quaternione
+		da un array.
+		</p>
+
+		<h3>[method:this identity]()</h3>
+		<p>
+			Imposta questo quaternione al quaterione identità; cioè al quaternione che rappresenta "nessuna rotazione".
+		</p>
+
+		<h3>[method:this invert]()</h3>
+		<p>
+			Inverte questo quaternione - calcola il [page:.conjugate coniugato]. Si presume che il quaternione abbia lunghezza unitaria.
+		</p>
+
+		<h3>[method:Float length]()</h3>
+		<p>Calcola la [link:https://en.wikipedia.org/wiki/Euclidean_distance lunghezza Euclidea]
+			(lunghezza in linea retta) di questo quaternione, considerato come un vettore a quattro dimensioni.
+		</p>
+
+		<h3>[method:Float lengthSq]()</h3>
+		<p>
+			Calcola la radice della [link:https://en.wikipedia.org/wiki/Euclidean_distance lunghezza Euclidea]
+			(lunghezza in linea retta) di questo quaternione, considerato come un vettore a quattro dimensioni.
+			Questo può essere utile se stai confrontando le lunghezze di due quaternioni, 
+			poiché questo è un calcolo leggermente più efficiente di [page:.length length]().
+		</p>
+
+		<h3>[method:this normalize]()</h3>
+		<p>
+			[link:https://en.wikipedia.org/wiki/Normalized_vector Normalizza] questo quaternione - cioè,
+			calcolato il quaternione che esegue la stessa rotazione di questo, ma con [page:.length lunghezza]
+			uguale a `1`.
+		</p>
+
+		<h3>[method:this multiply]( [param:Quaternion q] )</h3>
+		<p>Moltiplica questo quaternione per [page:Quaternion q].</p>
+
+		<h3>[method:this multiplyQuaternions]( [param:Quaternion a], [param:Quaternion b] )</h3>
+		<p>
+			Imposta questo quaternione a [page:Quaternion a] x [page:Quaternion b].<br />
+			Adattato dal metodo descritto [link:http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm qui].
+		</p>
+
+		<h3>[method:this premultiply]( [param:Quaternion q] )</h3>
+		<p>Pre-moltiplica questo quaternione per [page:Quaternion q].</p>
+
+		<h3>[method:this random]()</h3>
+		<p>
+			Imposta questo quaternione ad un quaternione normalizzato uniformemente casuale.
+		</p>
+
+		<h3>[method:this rotateTowards]( [param:Quaternion q], [param:Float step] )</h3>
+		<p>
+			[page:Quaternion q] - Il target quaternione.<br />
+			[page:Float step] - Il passo angolare in radianti.<br /><br />
+
+			Ruota questo quaternione di un dato passo angolare al quaternione definito *q*.
+			Il metodo assicura che il quaternione finale non superi *q*.
+		</p>
+
+		<h3>[method:this slerp]( [param:Quaternion qb], [param:Float t] )</h3>
+		<p>
+			[page:Quaternion qb] - L'altra rotazione del quaternione.<br />
+			[page:Float t] - Fattore di interpolazione nell'intervallo chiuso `[0, 1]`.<br /><br />
+
+			Gestisce l'interpolazione lineare tra i quaternioni. [page:Float t] rappresenta la quantità di rotazione
+			tra questo quaternione (dove [page:Float t] è 0) e [page:Quaternion qb] (dove
+			[page:Float t] è 1). Questo quaternione è impostato sul risultato. Vedi, anche, la versione
+			statica dello `slerp` qui sotto.
+
+			<code>
+			// ruota una mesh verso un quaternione target
+			mesh.quaternion.slerp( endQuaternion, 0.01 );
+			</code>
+		</p>
+
+		<h3>[method:this slerpQuaternions]( [param:Quaternion qa], [param:Quaternion qb], [param:Float t] )</h3>
+		<p>Esegue un'interpolazione sferica lineare tra i quaternioni dati e memorizza il risultato in questo quaternione.</p>
+
+		<h3>[method:this set]( [param:Float x], [param:Float y], [param:Float z], [param:Float w] )</h3>
+		<p>Imposta le proprietà [page:.x x], [page:.y y], [page:.z z], [page:.w w] di questo quaternione.</p>
+
+		<h3>[method:this setFromAxisAngle]( [param:Vector3 axis], [param:Float angle] )</h3>
+		<p>
+			Imposta questo quaternione dalla rotazione specificata dall'[page:Vector3 asse] e dall'[page:Float angolo].<br />
+			Adattato dal metodo [link:http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm qui].<br />
+			Si presume che l'`asse` sia normalizzato e l'`angolo` sia in radianti.
+		</p>
+
+		<h3>[method:this setFromEuler]( [param:Euler euler] )</h3>
+		<p>Imposta questo quaternione dalla rotazione specificata dall'angolo di [page:Eulero].</p>
+
+		<h3>[method:this setFromRotationMatrix]( [param:Matrix4 m] )</h3>
+		<p>
+		[page:Matrix4 m] - una [page:Matrix4] di cui il 3x3 superiore della matrice è una
+		[link:https://en.wikipedia.org/wiki/Rotation_matrix matrice di rotazione] pura (cioè non ridimensionata).<br />
+		Imposta questo quaternione dalla componente di rotazione di [page:Matrix4 m].<br />
+		Adattato dal metodo [link:http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm qui].
+		</p>
+
+		<h3>[method:this setFromUnitVectors]( [param:Vector3 vFrom], [param:Vector3 vTo] )</h3>
+		<p>
+			Imposta questo quaterione alla rotazinoe richiesta per ruotare il vettore di direzione [page:Vector3 vFrom] a
+			[page:Vector3 vTo].<br />
+			Adattato dal metodo [link:http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors qui].<br />
+			Si presume che [page:Vector3 vFrom] e [page:Vector3 vTo] siano normalizzati.
+		</p>
+
+		<h3>[method:Array toArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - Un array facoltativo per memorizzare il quaternione. Se non specificato, verrà creato un nuovo array.<br/>
+		[page:Integer offset] - (opzionale) se specificato, il risultato verrà copiato in questo [page:Array].<br /><br />
+
+		Restituisce gli elementi numerici di questo quaternione in un array del formato [x, y, z, w].
+		</p>
+
+		<h3>[method:this fromBufferAttribute]( [param:BufferAttribute attribute], [param:Integer index] )</h3>
+		<p>
+		[page:BufferAttribute attribute] - l'attributo sorgente.<br />
+		[page:Integer index] - l'indice dell'attributo.<br /><br />
+
+		Imposta le proprietà [page:.x x], [page:.y y], [page:.z z], [page:.w w] di questo quaternione dall'[page:BufferAttribute attributo].
+		</p>
+
+		<h2>Metodi Statici</h2>
+
+		<h3>[method:undefined slerpFlat]( [param:Array dst], [param:Integer dstOffset], [param:Array src0], [param:Integer srcOffset0], [param:Array src1], [param:Integer srcOffset1], [param:Float t] )</h3>
+		<p>
+		[page:Array dst] - L'array di output.<br />
+		[page:Integer dstOffset] - Un offset nell'array di output.<br />
+		[page:Array src0] - L'array sorgente del quaternione iniziale.<br />
+		[page:Integer srcOffset0] - Un offset nell'array `src0`.<br />
+		[page:Array src1] - L'array sorgente del quaternione target.<br />
+		[page:Integer srcOffset1] - Un offset nell'array `src1`.<br />
+		[page:Float t] - Fattore di interpolazione normalizzato (tra 0 e 1).<br /><br />
+
+		Questa implementazione SLERP presuppone che i dati del quaternione siano gestiti in array flat.
+		</p>
+
+		<h3>[method:Array multiplyQuaternionsFlat]( [param:Array dst], [param:Integer dstOffset], [param:Array src0], [param:Integer srcOffset0], [param:Array src1], [param:Integer srcOffset1] )</h3>
+		<p>
+		[page:Array dst] - L'array di output.<br />
+		[page:Integer dstOffset] - Un offset nell'array di output.<br />
+		[page:Array src0] - L'array sorgente del quaternione iniziale.<br />
+		[page:Integer srcOffset0] - Un offset nell'array `src0`.<br />
+		[page:Array src1] - L'array sorgente del quaternione target.<br />
+		[page:Integer srcOffset1] - Un offset nell'array `src1`.<br /><br />
+
+		Questa implementazione della moltiplicazione presuppone che i dati del quaterione siano gestiti in array flat.
+		</p>
+
+		<!-- Note: Do not add non-static methods to the bottom of this page. Put them above the <h2>Static Methods</h2> -->
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Ray.html

@@ -0,0 +1,210 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Un raggio che parte da un'origine e si dirige in una determinata direzione. Questo viene utilizzato
+			dal [page:Raycaster] per assistere il raycasting. Il raycasting viene utilizzato per selezionare
+			con il mouse (elaborare su quali oggetti nello spazio 3D si trova il mouse) tra le altre cose.
+		</p>
+
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]( [param:Vector3 origin], [param:Vector3 direction] )</h3>
+		<p>
+		[page:Vector3 origin] - (opzionale) l'origine del [page:Ray raggio]. Il valore predefinito è un [page:Vector3] a (0, 0, 0).<br />
+		[page:Vector3 direction] - [page:Vector3] La direzione del [page:Ray raggio]. Deve essere normalizzato
+		 (con [page:Vector3.normalize]) affinchè i metodi funzionino correttamente.  Il valore predefinito è [page:Vector3] a (0, 0, -1).<br /><br />
+
+		 Crea un nuovo [name].
+		</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Vector3 origin]</h3>
+		<p>L'origine del [page:Ray raggio]. Il valore predefinito è un [page:Vector3] a `(0, 0, 0)`.</p>
+
+		<h3>[property:Vector3 direction]</h3>
+		<p>
+			La direzione del [page:Ray raggio].  Deve essere normalizzato (con [page:Vector3.normalize])
+			affinchè i metodi funzionino correttamente. Il valore predefinito è un [page:Vector3] a (0, 0, -1).
+		</p>
+
+
+		<h2>Metodi</h2>
+
+		<h3>[method:this applyMatrix4]( [param:Matrix4 matrix4] )</h3>
+		<p>
+		[page:Matrix4 matrix4] - la [page:Matrix4] da applicare a questo [page:Ray raggio].<br /><br />
+
+		Trasforma questo [page:Ray raggio] con [page:Matrix4].
+		</p>
+
+		<h3>[method:Vector3 at]( [param:Float t], [param:Vector3 target] ) </h3>
+		<p>
+		[page:Float t] - la distanza lungo il [page:Ray raggio] per la quale recuperare una posizione.<br />
+		[page:Vector3 target] — il risultato sarà copiato in questo Vector3.<br /><br />
+
+		Ottiene un [page:Vector3] che corrisponde a una determinata distanza lungo questo [page:Ray raggio].
+		</p>
+
+		<h3>[method:Ray clone]()</h3>
+		<p>
+			Crea un nuovo raggio con [page:.origin origine] e [page:.direction direzione] identiche a questo.
+		</p>
+
+		<h3>[method:Vector3 closestPointToPoint]( [param:Vector3 point], [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 point] - il punto a cui avvicinarsi di più. <br />
+		[page:Vector3 target] — il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Ottiene il punto lungo questo [page:Ray raggio] che è il più vicino al [page:Vector3] fornito.
+		</p>
+
+		<h3>[method:this copy]( [param:Ray ray] )</h3>
+		<p>
+			Copia le proprietà [page:.origin origine] e [page:.direction direzione]
+			del [page:Ray raggio] in questo raggio.
+		</p>
+
+		<h3>[method:Float distanceSqToPoint]( [param:Vector3 point] )</h3>
+		<p>
+		[page:Vector3 point] - il [page:Vector3] per calcolare una distanza.<br /><br />
+
+		Ottiene la distanza al quadrato dell'avvicinamento più vicino tra il [page:Ray raggio] e il [page:Vector3].
+		</p>
+
+		<h3>[method:Float distanceSqToSegment]( [param:Vector3 v0], [param:Vector3 v1], [param:Vector3 optionalPointOnRay], [param:Vector3 optionalPointOnSegment] )</h3>
+		<p>
+		[page:Vector3 v0] - l'inizio del segmento.<br />
+		[page:Vector3 v1] - la fine del segmento.<br />
+		optionalPointOnRay - (opzionale) se viene fornito, riceve il punto su questo
+			[page:Ray raggio] più vicino al segmento.<br />
+		optionalPointOnSegment - (opzionale) se viene fornito, riceve il punto
+		sul segmento più vicino al [page:Ray raggio].<br /><br />
+
+		Ottiene la distanza al quadrato tra questo [page:Ray raggio] e un segmento.
+		</p>
+
+		<h3>[method:Float distanceToPlane]( [param:Plane plane] )</h3>
+		<p>
+		[page:Plane plane] - il [page:Plane] per ottenere la distanza.<br /><br />
+
+		Ottiene la distanza tra l'[page:.origin origine] e il [page:Plane piano], o `null` se il [page:Ray raggio] non interseca il [page:Plane piano].
+		</p>
+
+		<h3>[method:Float distanceToPoint]( [param:Vector3 point] )</h3>
+		<p>
+		[page:Vector3 point] - Il [page:Vector3] su cui calcolare la distanza.<br /><br />
+
+		Ottiene la distanza dell'avvicinamento più vicino tra il [page:Ray raggio] e il [page:Vector3 punto].
+		</p>
+
+
+		<h3>[method:Boolean equals]( [param:Ray ray] )</h3>
+		<p>
+		[page:Ray ray] - il [page:Ray raggio] su cui confrontare.<br /><br />
+
+		Restituisce true se questo e l'altro [page:Ray raggio] hanno [page:.origin origine]
+		e [page:.direction direzione] uguali.
+		</p>
+
+		<h3>[method:Vector3 intersectBox]( [param:Box3 box], [param:Vector3 target] )</h3>
+		<p>
+		[page:Box3 box] - il [page:Box3] con cui intersecare.<br />
+		[page:Vector3 target] — il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Interseca questo [page:Ray raggio] con un [page:Box3], restituendo il punto di intersezione o
+		`null` se non ci sono intersezioni.
+		</p>
+
+		<h3>[method:Vector3 intersectPlane]( [param:Plane plane], [param:Vector3 target] )</h3>
+		<p>
+		[page:Plane plane] - il [page:Plane] con cui intersecare.<br />
+		[page:Vector3 target] — il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Interseca questo [page:Ray raggio] con un [page:Plane], restituendo il punto di intersezione o
+		`null` se non ci sono intersezioni.
+		</p>
+
+		<h3>[method:Vector3 intersectSphere]( [param:Sphere sphere], [param:Vector3 target] )</h3>
+		<p>
+		[page:Sphere sphere] - la [page:Sphere] con cui intersecare.<br />
+		[page:Vector3 target] — il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Interseca questo [page:Ray raggio] con una [page:Sphere], restituendo il punto di intersezione o
+		`null` se non ci sono intersezioni.
+		</p>
+
+		<h3>[method:Vector3 intersectTriangle]( [param:Vector3 a], [param:Vector3 b], [param:Vector3 c], [param:Boolean backfaceCulling], [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 a], [page:Vector3 b], [page:Vector3 c] - I punti [page:Vector3] che compongono il triangolo.<br />
+		[page:Boolean backfaceCulling] - se utilizzare backface culling o meno.<br />
+		[page:Vector3 target] — il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Interseca questo [page:Ray raggio] con un triangolo, restituendo il punto di intersezione o
+		`null` se non ci sono intersezioni.
+		</p>
+
+		<h3>[method:Boolean intersectsBox]( [param:Box3 box] )</h3>
+		<p>
+		[page:Box3 box] - il [page:Box3] con cui intersecare.<br /><br />
+
+		Restituisce true se questo [page:Ray raggio] si interseca con il [page:Box3].
+		</p>
+
+		<h3>[method:Boolean intersectsPlane]( [param:Plane plane] )</h3>
+		<p>
+		[page:Plane plane] - il [page:Plane] con cui intersecare.<br /><br />
+
+		Restituisce true se questo [page:Ray raggio] si interseca con il [page:Plane].
+		</p>
+
+		<h3>[method:Boolean intersectsSphere]( [param:Sphere sphere] )</h3>
+		<p>
+		[page:Sphere sphere] - la [page:Sphere] con cui intersecare.<br /><br />
+
+		Restituisce true se questo [page:Ray raggio] si interseca con la [page:Sphere].
+		</p>
+
+		<h3>[method:this lookAt]( [param:Vector3 v] )</h3>
+		<p>
+		[page:Vector3 v] - Il [page:Vector3] da guardare.<br /><br />
+
+		Regola la direzione del raggio in modo che punti al vettore nelle coordinate world.
+		</p>
+
+		<h3>[method:this recast]( [param:Float t] )</h3>
+		<p>
+		[page:Float t] - La distanza lungo il [page:Ray raggio] da interpolare.<br /><br />
+
+		Sposta l'origine di questo [page:Ray raggio] lungo le sue direzione per la distanza data.
+		</p>
+
+		<h3>[method:this set]( [param:Vector3 origin], [param:Vector3 direction] )</h3>
+		<p>
+		[page:Vector3 origin] - l'[page:.origin origine] del [page:Ray raggio].<br />
+		[page:Vector3 origin] - la [page:.direction direzione] del [page:Ray raggio].
+		Deve essere normalizzato (con [page:Vector3.normalize]) affinchè i metodi funzionino correttamente.<br /><br />
+
+		Imposta le proprietà [page:.origin origine] e [page:.direction direzione] di questo raggio copiando i valori dagli oggetti dati.
+		</p>
+
+
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Sphere.html

@@ -0,0 +1,160 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">Una sfera definita da un centro e un raggio.</p>
+
+		<h2>Costruttore</h2>
+		<h3>[name]( [param:Vector3 center], [param:Float radius] )</h3>
+		<p>
+		[page:Vector3 center] - centro della sfera. Il valore predefinito è un [page:Vector3] a `(0, 0, 0)`. <br />
+		[page:Float radius] - raggio della sfera. Il valore predefinito è -1.<br /><br />
+
+		Crea una nuova [name].
+
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+
+		<h3>[property:Vector3 center]</h3>
+		<p>Un [page:Vector3] che definisce il centro della sfera. Il valore predefinito è `(0, 0, 0)`.</p>
+
+		<h3>[property:Float radius]</h3>
+		<p>Il raggio della sfera. Il valore predefinito è -1.</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:this applyMatrix4]( [param:Matrix4 matrix] )</h3>
+		<p>
+			[page:Matrix4 matrix] - [Page:Matrix4] da applicare. <br /><br />
+
+			Trasforma questa sfera con la [page:Matrix4] fornita.
+		</p>
+
+		<h3>[method:Vector3 clampPoint]( [param:Vector3 point], [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 point] - [page:Vector3] Il punto da bloccare.<br />
+		[page:Vector3 target] — Il risultato verrà copiato in questo Vector3.<br /><br />
+
+		Blocca un punto all'interno della sfera. Se il punto è fuori dalla sfera, lo bloccherà al punto 
+		più vicino sul bordo della sfera. I punti già all'interno della sfera non saranno influenzati.
+		</p>
+
+		<h3>[method:Sphere clone]()</h3>
+		<p>Restituisce un nuova sfera con lo stesso [page:.center centro] e [page:.radius raggio] di questa.</p>
+
+		<h3>[method:Boolean containsPoint]( [param:Vector3 point] )</h3>
+		<p>
+		[page:Vector3 point] - il [page:Vector3] da controllare.<br /><br />
+
+		Controlla se la sfera contiene il [page:Vector3 punto] fornito comprensivo della superficie della sfera.
+		</p>
+
+		<h3>[method:this copy]( [param:Sphere sphere] )</h3>
+		<p>
+			Copia i valori delle proprietà [page:.center centro] e [page:.radius raggio] della sfera passata 
+			in questa sfera.
+		</p>
+
+		<h3>[method:Float distanceToPoint]( [param:Vector3 point] )</h3>
+		<p>
+			Restituisce la distanza più vicina dal confine della sfera al [page:Vector3 punto]. Se la sfera contiene il punto, 
+			la distanza sarà negativa.
+		</p>
+
+		<h3>[method:this expandByPoint]( [param:Vector3 point] )</h3>
+		<p>
+		[page:Vector3 point] - [page:Vector3] che da includere nella sfera.<br /><br />
+
+		Espande i confini della sfera per includere il [page:Vector3 punto].
+		</p>
+
+		<h3>[method:Boolean isEmpty]()</h3>
+		<p>
+			Controlla se la sfera è vuota (il raggio impostato ad un numero negativo).</br>
+			Le sfere con un raggio di 0 contengono solo il loro punto centrale e non sono considerate vuote.
+		</p>
+
+		<h3>[method:this makeEmpty]()</h3>
+		<p>Rende la sfera vuota impostando il [page:.center centro] a (0, 0, 0) e il [page:.radius raggio] a -1.</p>
+
+		<h3>[method:Boolean equals]( [param:Sphere sphere] )</h3>
+		<p>
+			Controlla se i due centri e i due raggi sono uguali.
+		</p>
+
+		<h3>[method:Box3 getBoundingBox]( [param:Box3 target] )</h3>
+		<p>
+		[page:Box3 target] — Il risultato verrà copiato in questo Box3.<br /><br />
+
+		Restituisce un [link:https://en.wikipedia.org/wiki/Minimum_bounding_box Minimum Bounding Box] per la sfera.
+		</p>
+
+		<h3>[method:Boolean intersectsBox]( [param:Box3 box] )</h3>
+		<p>
+		[page:Box3 box] - [page:Box3] per verificare la presenza di intersezioni.<br /><br />
+		
+		Determina se questa sfera interseca il [page:Box3 box] dato oppure no.
+		</p>
+
+		<h3>[method:Boolean intersectsPlane]( [param:Plane plane] )</h3>
+		<p>
+		[page:Plane plane] - Plane per verificare la presenza di intersezioni.<br /><br />
+
+		Determina se questa sfera interseca il [page:Plane plane] dato oppure no.
+		</p>
+
+		<h3>[method:Boolean intersectsSphere]( [param:Sphere sphere] )</h3>
+		<p>
+		[page:Sphere sphere] - Sphere per verificare la presenza di intersezioni.<br /><br />
+
+		Verifica se le due sfere si intersecano.
+		</p>
+
+		<h3>[method:this set]( [param:Vector3 center], [param:Float radius] )</h3>
+		<p>
+			[page:Vector3 center] - centro della sfera.<br />
+			[page:Float radius] - raggio della sfera.<br /><br />
+
+			Imposta le proprietà [page:.center centro] e [page:.radius raggio] di questa sfera.<br>
+			Si noti che questo metodo copia solo i valori per il centro dato.
+		</p>
+
+		<h3>[method:this setFromPoints]( [param:Array points], [param:Vector3 optionalCenter] )</h3>
+		<p>
+		[page:Array points] - un [page:Array] di posizioni [page:Vector3].<br />
+		[page:Vector3 optionalCenter] - Posizione [page:Vector3] opzionale per il centro della sfera.<br /><br />
+
+		Calcola la sfera di delimitazione minima per un array di [page:Array punti]. Se viene fornito l'[page:Vector3 optionalCenter],
+		viene utilizzato con il centro della sfera. Altrimenti, viene calcolato il centro del rettangolo di selezione allineato
+		agli assi che comprende i [page:Array punti].
+		</p>
+
+		<h3>[method:this translate]( [param:Vector3 offset] )</h3>
+		<p>
+			Trasla il centro della sfera dell'offset [page:Vector3] fornito.
+		</p>
+
+		<h3>[method:this union]( [param:Sphere sphere] )</h3>
+		<p>
+		[page:Sphere sphere] - Sfera di delimitazione che sarà unita a questa sfera.<br /><br />
+
+		Espande questa sfera per racchiudere sia la sfera originale che quella data.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Spherical.html

@@ -0,0 +1,79 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">Le [link:https://en.wikipedia.org/wiki/Spherical_coordinate_system coordinate sferiche] di un punto.</p>
+
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]( [param:Float radius], [param:Float phi], [param:Float theta] )</h3>
+		<p>
+		[page:Float radius] - il raggio, o la [link:https://en.wikipedia.org/wiki/Euclidean_distance distanza Euclidea]
+		(distanza in linea retta) dal punto all'origine. Il valore predefinito è `1.0`.<br />
+		[page:Float phi] - angolo polare in radianti dall'asse y (su). Il valore predefinito è `0`.<br />
+		[page:Float theta] - angolo dell'equatore in radianti attorno l'asse y (su). Il valore predefinito è `0`.<br /><br />
+
+		I poli (phi) sono sull'asse positivo e negativo. L'equatore (theta) inizia con z positivo.
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Float radius]</h3>
+
+		<h3>[property:Float phi]</h3>
+
+		<h3>[property:Float theta]</h3>
+
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Spherical clone]()</h3>
+		<p>
+			Restituisce una nuova [name] con le stesse proprietà [page:.radius radius], [page:.phi phi]
+			e [page:.theta theta] di questo.
+		</p>
+
+		<h3>[method:this copy]( [param:Spherical s] )</h3>
+		<p>
+			Copia i valori delle proprietà [page:.radius radius], [page:.phi phi]
+			e [page:.theta theta] della sferica a questa sferica.
+		</p>
+
+		<h3>[method:this makeSafe]()</h3>
+		<p>
+			Limita l'angolo polare [page:.phi phi] per essere tra 0.000001 e pi - 0.000001.
+		</p>
+
+		<h3>[method:this set]( [param:Float radius], [param:Float phi], [param:Float theta] )</h3>
+		<p>Imposta i valori delle proprietà [page:.radius radius], [page:.phi phi]
+		e [page:.theta theta] di questa sferica.</p>
+
+		<h3>[method:this setFromVector3]( [param:Vector3 vec3] )</h3>
+		<p>
+			Imposta i valori delle proprietà [page:.radius radius], [page:.phi phi]
+			e [page:.theta theta] di questa sferica dal [page:Vector3 Vector3].
+		</p>
+
+		<h3>[method:this setFromCartesianCoords]( [param:Float x], [param:Float y], [param:Float z] )</h3>
+		<p>
+			Imposta i valori delle proprietà [page:.radius radius], [page:.phi phi]
+			e [page:.theta theta] di questa sferica dalle coordinate cartesiane.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/SphericalHarmonics3.html

@@ -0,0 +1,145 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Rappresenta un'armonica sferica del terzo ordine (SH). Le sonde luminose utilizzano questa classe per codificare le 
+			informazioni sull'illuminazione.
+		</p>
+
+		<h2>Costruttore</h2>
+		<h3>[name]()</h3>
+		<p>
+			Crea una nuova istanza di [name].
+		</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Array coefficients]</h3>
+		<p>Un array contenente i (9) coefficienti SH. Un singolo coefficiente è rappresentato come un'istanza di [page:Vector3].</p>
+
+		<h3>[property:Boolean isSphericalHarmonics3]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:this add]( [param:SphericalHarmonics3 sh] )</h3>
+		<p>
+			[page:SphericalHarmonics3 sh] - L'SH da aggiungere.<br /><br />
+
+			Aggiunge l'SH dato a questa istanza.
+		</p>
+
+		<h3>[method:this addScaledSH]( [param:SphericalHarmonics3 sh], [param:Number scale] )</h3>
+		<p>
+			[page:SphericalHarmonics3 sh] - L'SH da aggiungere.<br />
+			[page:Number scale] - Il fattore scale.<br /><br />
+
+			Un metodo pratico per eseguire [page:.add]() e [page:.scale]() contemporaneamente.
+		</p>
+
+		<h3>[method:SphericalHarmonics3 clone]()</h3>
+		<p>
+			Restituisce una nuova istanza di [name] con i coefficienti uguali.
+		</p>
+
+		<h3>[method:this copy]( [param:SphericalHarmonics3 sh] )</h3>
+		<p>
+			[page:SphericalHarmonics3 sh] - L'SH da copiare.<br /><br />
+
+			Copia l'SH dato per questa istanza.
+		</p>
+
+		<h3>[method:Boolean equals]( [param:SphericalHarmonics3 sh] )</h3>
+		<p>
+			[page:SphericalHarmonics3 sh] - L'SH con cui fare la comparazione.<br /><br />
+
+			Restituisce true se l'SH dato e questa istanza hanno coefficienti uguali.
+		</p>
+
+		<h3>[method:this fromArray]( [param:Array array], [param:Number offset] )</h3>
+		<p>
+			[page:Array array] - L'array contiene i numeri dei coefficienti SH.<br />
+			[page:Number offset] - (opzionale) L'offset dell'array.<br /><br />
+
+			Imposta i coefficienti di questa istanza dall'array passato.
+		</p>
+
+		<h3>[method:Vector3 getAt]( [param:Vector3 normal], [param:Vector3 target] )</h3>
+		<p>
+			[page:Vector3 normal] - Il vettore normale (si assume che abbia lunghezza unitaria).<br />
+			[page:Vector3 target] - Il vettore risultato.<br /><br />
+
+			Restituisce la radianza nella direzione della normale data.
+		</p>
+
+		<h3>[method:Vector3 getIrradianceAt]( [param:Vector3 normal], [param:Vector3 target] )</h3>
+		<p>
+			[page:Vector3 normal] - Il vettore normale (si assume che abbia lunghezza unitaria).<br />
+			[page:Vector3 target] - Il vettore risultato.<br /><br />
+
+			Restituisce l'irradianza (radianza convoluta con il lobo del coseno) nella direzione della normale data.
+		</p>
+
+		<h3>[method:this lerp]( [param:SphericalHarmonics3 sh], [param:Number alpha] )</h3>
+		<p>
+			[page:SphericalHarmonics3 sh] - L'SH con cui interpolare.<br />
+			[page:Number alpha] - Il fattore alfa.<br /><br />
+
+			Interpolazioni lineari tra l'SH dato e questa istanza dal fattore alfa dato.
+		</p>
+
+		<h3>[method:this scale]( [param:Number scale] )</h3>
+		<p>
+			[page:Number scale] - Il fattore scale.<br /><br />
+
+			Ridimensiona questo SH in base al fattore scale passato.
+		</p>
+
+		<h3>[method:this set]( [param:Array coefficients] )</h3>
+		<p>
+			[page:Array coefficients] - Un array di coefficienti SH.<br /><br />
+
+			Imposta i coefficienti SH passati in questa istanza.
+		</p>
+
+		<h3>[method:Array toArray]( [param:Array array], [param:Number offset] )</h3>
+		<p>
+			[page:Array array] - (opzionale) L'array target.<br />
+			[page:Number offset] - (opzionale) L'array offset.<br /><br />
+
+			Restituisce un array con i coefficienti, o li copia nell'array fornito. I coefficienti
+			sono rappresentati come numeri.
+		</p>
+
+		<h3>[method:this zero]()</h3>
+		<p>
+			Imposta tutti i coefficienti a 0.
+		</p>
+
+		<h2>Metodi Statici</h2>
+
+		<h3>[method:undefined getBasisAt]( [param:Vector3 normal], [param:Array shBasis] )</h3>
+		<p>
+			[page:Vector3 normal] - Il vettore normale (si presume che abbia lunghezza unitaria).<br />
+			[page:Array shBasis] - La base SH risultante.<br /><br />
+
+			Calcola la base SH per il vettore normale passato.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Triangle.html

@@ -0,0 +1,171 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Un triangolo geometrico definito da tre [page:Vector3 Vector3] che rappresentano i suoi tre angoli.
+		</p>
+
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]( [param:Vector3 a], [param:Vector3 b], [param:Vector3 c] )</h3>
+		<p>
+		[page:Vector3 a] - il primo angolo del triangolo. Il valore predefinito è un [page:Vector3] a `(0, 0, 0)`.<br />
+		[page:Vector3 b] - il secondo angolo del triangolo. Il valore predefinito è un [page:Vector3] a `(0, 0, 0)`.<br />
+		[page:Vector3 c] - il terzo angolo del triangolo. Il valore predefinito è un [page:Vector3] a `(0, 0, 0)`.<br /><br />
+
+		Crea un nuovo [name].
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Vector3 a]</h3>
+		<p>
+			Il primo angolo del triangolo. Il valore predefinito è un [page:Vector3] a `(0, 0, 0)`.
+		</p>
+
+		<h3>[property:Vector3 b]</h3>
+		<p>
+			Il secondo angolo del triangolo. Il valore predefinito è un [page:Vector3] a `(0, 0, 0)`.
+		</p>
+
+		<h3>[property:Vector3 c]</h3>
+		<p>
+			Il terzo angolo del triangolo. Il valore predefinito è un [page:Vector3] a `(0, 0, 0)`.
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Triangle clone]()</h3>
+		<p>
+			Restituisce un nuovo triangolo con le stesse proprietà [page:.a a], [page:.b b] e [page:.c c] di questo.
+		</p>
+
+		<h3>[method:Vector3 closestPointToPoint]( [param:Vector3 point], [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 point] - [page:Vector3] <br />
+		[page:Vector3 target] — il risultato sarà copiato in questo Vector3.<br /><br />
+
+		Restituisce il punto più vicino del triangolo al [page:Vector3 punto].
+		</p>
+
+		<h3>[method:Boolean containsPoint]( [param:Vector3 point] )</h3>
+		<p>
+		[page:Vector3 point] - [page:Vector3] da controllare.<br /><br />
+
+		Restituisce true se il punto passato, quando proiettato sul piano del triangolo, si trova all'interno del triangolo.
+		</p>
+
+		<h3>[method:this copy]( [param:Triangle triangle] )</h3>
+		<p>
+			Copia i valori delle proprietà [page:.a a], [page:.b b] e [page:.c c] del triangolo passato in questo triangolo.
+		</p>
+
+		<h3>[method:Boolean equals]( [param:Triangle triangle] )</h3>
+		<p>
+			Restituisce true se i due triangoli hanno le proprietà [page:.a a], [page:.b b] e [page:.c c] identiche.
+		</p>
+
+		<h3>[method:Float getArea]()</h3>
+		<p>Restituisce l'area del triangolo.</p>
+
+		<h3>[method:Vector3 getBarycoord]( [param:Vector3 point], [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 point] - [page:Vector3] <br />
+		[page:Vector3 target] — il risultato sarà copiato in questo Vector3.<br /><br />
+
+		Restituisce una [link:https://en.wikipedia.org/wiki/Barycentric_coordinate_system coordinata baricentrica]
+		dal vettore dato. <br/><br/>
+
+		[link:http://commons.wikimedia.org/wiki/File:Barycentric_coordinates_1.png Figura delle coordinate baricentriche]
+		</p>
+
+		<h3>[method:Vector3 getMidpoint]( [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 target] — il risultato sarà copiato in questo  Vector3.<br /><br />
+
+		Calcola il punto medio del triangolo.
+		</p>
+
+		<h3>[method:Vector3 getNormal]( [param:Vector3 target] )</h3>
+		<p>
+		[page:Vector3 target] — il risultato sarà copiato in questo Vector3.<br /><br />
+
+		Calcola il [link:https://en.wikipedia.org/wiki/Normal_(geometry) vettore normale] del triangolo.
+		</p>
+
+		<h3>[method:Plane getPlane]( [param:Plane target] )</h3>
+		<p>
+		[page:Plane target] — il risultato sarà copiato in questo Plane.<br /><br />
+
+		Calcola il [page:Plane piano] in base al triangolo.
+		</p>
+
+		<h3>[method:Vector2 getUV]( [param:Vector3 point], [param:Vector2 uv1], [param:Vector2 uv2], [param:Vector2 uv3], [param:Vector2 target] )</h3>
+		<p>
+		[page:Vector3 point] - Il punto sul triangolo.<br />
+		[page:Vector2 uv1] - La coordinata uv del primo vertice del triangolo.<br />
+		[page:Vector2 uv2] - La coordinata uv del secondo vertice del triangolo.<br />
+		[page:Vector2 uv3] - La coordinata uv del terzo vertice del triangolo.<br />
+		[page:Vector2 target] — il risultato sarà copiato in questo Vector2.<br /><br />
+
+		Restituisce le coordinate uv per il punto specificato sul triangolo.
+		</p>
+
+		<h3>[method:Boolean intersectsBox]( [param:Box3 box] )</h3>
+		<p>
+		[page:Box3 box] - Box per il controllo dell'intersezione.<br /><br />
+
+		Determina se il triangolo interseca [page:Box3 box] oppure no.
+		</p>
+
+		<h3>[method:Boolean isFrontFacing]( [param:Vector3 direction] )</h3>
+		<p>
+		[page:Vector3 direction] - La distanza da testare.<br /><br />
+
+		Determina se il triangolo è orientato verso la direzione data o no.
+		</p>
+
+		<h3>[method:this set]( [param:Vector3 a], [param:Vector3 b], [param:Vector3 c] ) [param:Triangle this]</h3>
+		<p>
+			Imposta le proprietà [page:.a a], [page:.b b] e [page:.c c] del triangolo ai [page:Vector3 vector3] passati.<br>
+			Si noti che questo metodo copia solamente i valori da un dato oggetto.
+		</p>
+
+		<h3>[method:this setFromAttributeAndIndices]( [param:BufferAttribute attribute], [param:Integer i0], [param:Integer i1], [param:Integer i2] ) [param:Triangle this]</h3>
+		<p>
+		attribute - [page:BufferAttribute] dei dati del vertice <br />
+		i0 - [page:Integer] indice <br />
+		i1 - [page:Integer] indice <br />
+		i2 - [page:Integer] indice<br /><br />
+
+		Imposta i vertici del triangolo dai dati dei vertici dell'attributo buffer.
+		</p>
+
+		<h3>[method:this setFromPointsAndIndices]( [param:Array points], [param:Integer i0], [param:Integer i1], [param:Integer i2] ) [param:Triangle this]</h3>
+		<p>
+		points - [page:Array] di [page:Vector3] <br />
+		i0 - [page:Integer] indice <br />
+		i1 - [page:Integer] indice <br />
+		i2 - [page:Integer] indice<br /><br />
+
+		Imposta i vettori del triangolo ai vettori nell'array.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Vector2.html

@@ -0,0 +1,354 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Classe che rappresenta un [link:https://en.wikipedia.org/wiki/Vector_space vettore] 2D.
+
+			Un vettore 2D è una coppia ordinata di numeri (etichettati con x e y), che può essere
+			utilizzata per rappresentare una serie di cose, come:
+		</p>
+
+		<ul>
+			<li>
+				Un punto nello spazio 2D (cioè una posizione su un piano).
+			</li>
+			<li>
+				Una direzione e lunghezza su un piano. In three.js la lunghezza sarà sempre la 
+				[link:https://en.wikipedia.org/wiki/Euclidean_distance distanza Euclidea]
+				(distanza in liena retta) da `(0, 0)` a `(x, y)` e anche la direzione viene misurata da
+				 `(0, 0)` verso `(x, y)`.
+			</li>
+			<li>
+				Qualsiasi coppia di numeri ordinata arbitrariamente.
+			</li>
+		</ul>
+
+		<p>
+			Ci sono altre cose che possono essere rappresentate da un vettore 2D, come i vettori 
+			di quantità di moto, numeri complessi e così via, tuttavia questi sono gli usi comuni in three.js.
+		</p>
+
+		<p>
+			L'iterazione di un'istanza [name] produrrà i suoi componenti `(x, y)` nell'ordine corrispondente.
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const a = new THREE.Vector2( 0, 1 );
+
+		// nessun argomento; sarà inizializzato a (0, 0)
+		const b = new THREE.Vector2( );
+
+		const d = a.distanceTo( b );
+		</code>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( [param:Float x], [param:Float y] )</h3>
+		<p>
+		[page:Float x] - il valore x di questo vettore. Il valore predefinito è `0`.<br />
+		[page:Float y] -  il valore y di questo vettore. Il valore predefinito è `0`.<br /><br />
+
+		Crea un nuovo [name].
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Float height]</h3>
+		<p>Alternativa per [page:.y y].</p>
+
+		<h3>[property:Boolean isVector2]</h3>
+		<p>
+			Flag di sola lettura per verificare che l'oggetto dato sia di tipo [name].
+		</p>
+
+		<h3>[property:Float width]</h3>
+		<p>lternativa per [page:.x x].</p>
+
+		<h3>[property:Float x]</h3>
+
+		<h3>[property:Float y]</h3>
+
+
+		<h2>Metodi</h2>
+
+		<h3>[method:this add]( [param:Vector2 v] )</h3>
+		<p>Aggiunge [page:Vector2 v] a questo vettore.</p>
+
+		<h3>[method:this addScalar]( [param:Float s] )</h3>
+		<p>Aggiunge il valore scalare [page:Float s] ai valori [page:.x x] e [page:.y y] di questo vettore.</p>
+
+		<h3>[method:this addScaledVector]( [param:Vector2 v], [param:Float s] )</h3>
+		<p>Aggiunge il multiplo di [page:Vector2 v] e [page:Float s] a questo vettore.</p>
+
+		<h3>[method:this addVectors]( [param:Vector2 a], [param:Vector2 b] )</h3>
+		<p>Imposta questo vettore a [page:Vector2 a] + [page:Vector2 b].</p>
+
+		<h3>[method:Float angle]()</h3>
+		<p>
+			Calcola l'angolo in radianti di questo vettore rispetto all'asse x positivo. 
+		</p>
+
+		<h3>[method:this applyMatrix3]( [param:Matrix3 m] )</h3>
+		<p>
+			Moltiplica questo vettore (con un 1 implicito come terza componente) per m.
+		</p>
+
+		<h3>[method:this ceil]()</h3>
+		<p>
+			I componenti [page:.x x] e [page:.y y] di questo vettore vengono arrotondati per eccesso al valore intero più vicino. 
+		</p>
+
+		<h3>[method:this clamp]( [param:Vector2 min], [param:Vector2 max] )</h3>
+		<p>
+		[page:Vector2 min] - i valori minimi x e y.<br />
+		[page:Vector2 max] - i valori massimi x e y nell'intervallo desiderato.<br /><br />
+
+		Se il valore x o y di questo vettore è maggiore del valore x o y del vettore massimo, verrà sostituito dal valore corrispondente.<br /><br />
+		Se il valore x o y di questo vettore è minore del valore x o y del vettore minimo, verrà sostituito dal valore corrispondente.<br /><br />
+		</p>
+
+		<h3>[method:this clampLength]( [param:Float min], [param:Float max] )</h3>
+		<p>
+		[page:Float min] - il valore minimo a cui verrà fissata la lunghezza. <br />
+		[page:Float max] - il valore massimo a cui verrà fissata la lunghezza.<br /><br />
+
+		Se la lunghezza di questo vettore è maggiore del valore massimo, verrà sostituita dal valore massimo.<br /><br />
+		Se la lunghezza di questo vettore è minore del valore minimo, verrà sostituita dal valore minimo.
+		</p>
+
+		<h3>[method:this clampScalar]( [param:Float min], [param:Float max] )</h3>
+		<p>
+		[page:Float min] - il valore minimo a cui verranno fissati i componenti.<br />
+		[page:Float max] - il valore massimo a cui verranno fissati i componenti.<br /><br />
+
+		Se i valori di x o y di questo vettore sono maggiori del valore massimo, verranno sostuiti dal valore massimo.<br /><br />
+		Se i valori di x o y di questo vettore sono minori del valore minimo, verranno sostuiti dal valore minimo.
+		</p>
+
+		<h3>[method:Vector2 clone]()</h3>
+		<p>
+			Restituisce un nuovo Vector2 con gli stessi valori [page:.x x] e [page:.y y] di questo.
+		</p>
+
+		<h3>[method:this copy]( [param:Vector2 v] )</h3>
+		<p>
+			Copia i valori delle proprietà [page:.x x] e [page:.y y] del vettore passate di questo Vector2.
+		</p>
+
+		<h3>[method:Float distanceTo]( [param:Vector2 v] )</h3>
+		<p>Calcola la distanza da questo vettore a [page:Vector2 v].</p>
+
+		<h3>[method:Float manhattanDistanceTo]( [param:Vector2 v] )</h3>
+		<p>
+			Calcola la [link:https://en.wikipedia.org/wiki/Taxicab_geometry distanza Manhattan] da questo vettore a [page:Vector2 v].
+		</p>
+
+		<h3>[method:Float distanceToSquared]( [param:Vector2 v] )</h3>
+		<p>
+			Calcola la distanza al quadrato da questo vettore a [page:Vector2 v]. Se stai semplicemente
+			confrontando la distanza con un'altra distanza, dovresti invece confrontare la distanza al quadrato
+			poiché è leggermente più efficiente da calcolare.
+		</p>
+
+		<h3>[method:this divide]( [param:Vector2 v] )</h3>
+		<p>Divide questo vettore per [page:Vector2 v].</p>
+
+		<h3>[method:this divideScalar]( [param:Float s] )</h3>
+		<p>
+			Divide questo vettore per lo scalare [page:Float s].
+		</p>
+
+		<h3>[method:Float dot]( [param:Vector2 v] )</h3>
+		<p>
+			Calcola il [link:https://en.wikipedia.org/wiki/Dot_product prodotto scalare] di questo vettore e
+	  	[page:Vector2 v].
+		</p>
+
+		<h3>[method:Float cross]( [param:Vector2 v] )</h3>
+		<p>
+			Calcola il [link:https://en.wikipedia.org/wiki/Cross_product prodotto vettoriale] di questo vettore e
+	  	[page:Vector2 v]. Si noti che un 'prodotto vettoriale' in 2D non è ben definito. 
+			Questa funzione calcola un prodotto vettoriale geometrico spesso utilizzato nella grafica 2D.
+		</p>
+
+		<h3>[method:Boolean equals]( [param:Vector2 v] )</h3>
+		<p>Restituisce `true` se il componente di questo vettore e [page:Vector2 v] sono strettamente uguali; `false` altrimenti.</p>
+
+		<h3>[method:this floor]()</h3>
+		<p>I componenti di questo vettore vengono arrotondati per difetto al valore intero più vicino.</p>
+
+		<h3>[method:this fromArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - l'array sorgente.<br />
+		[page:Integer offset] - (opzionale) l'offset nell'array. Il valore predefinito è 0.<br /><br />
+
+		Imposta il valore [page:.x x] di questo vettore su `array[ offset ]` e il valore [page:.y y] su `array[ offset + 1 ]`.
+		</p>
+
+		<h3>[method:this fromBufferAttribute]( [param:BufferAttribute attribute], [param:Integer index] )</h3>
+		<p>
+		[page:BufferAttribute attribute] - l'array sorgente.<br />
+		[page:Integer index] - indice nell'attributo.<br /><br />
+
+		Imposta i valori [page:.x x] e [page:.y y] di questo vettore nell'[page:BufferAttribute attributo].
+		</p>
+
+		<h3>[method:Float getComponent]( [param:Integer index] )</h3>
+		<p>
+		[page:Integer index] - 0 o 1.<br /><br />
+
+		Se l'indice è uguale 0 restituisce il valore [page:.x x]. <br />
+		Se l'indice è uguale 1 restituisce il valore [page:.y y].
+		</p>
+
+		<h3>[method:Float length]()</h3>
+		<p>
+			Calcola la [link:https://en.wikipedia.org/wiki/Euclidean_distance lunghezza Euclidea]
+			(lunghezza in linea retta) da (0, 0) a (x, y).</p>
+
+		<h3>[method:Float manhattanLength]()</h3>
+		<p>
+			Calcola la [link:http://en.wikipedia.org/wiki/Taxicab_geometry lunghezza Manhattan] di questo vettore.
+		</p>
+
+		<h3>[method:Float lengthSq]()</h3>
+		<p>
+			Calcola il quadrato della [link:https://en.wikipedia.org/wiki/Euclidean_distance lunghezza Euclidea]
+			(lunghezza in linea retta) da (0, 0) a (x, y). Se stai comparando le lunghezze dei vettori, dovresti invece
+			confrontare la lunghezza quadrata poiché è leggermente più efficiente da calcolare.
+		</p>
+
+		<h3>[method:this lerp]( [param:Vector2 v], [param:Float alpha] )</h3>
+		<p>
+		[page:Vector2 v] - [page:Vector2] verso cui interpolare.<br />
+		[page:Float alpha] - fattore interpolazione, tipicamente nell'intervallo chiuso `[0, 1]`.<br /><br />
+
+		Interpola linearmente tra questo vettore e [page:Vector2 v], dove alfa è la distanza percentuale
+		lungo la linea - alfa = 0 sarà questo vettore e alfa = 1 sarà [page:Vector2 v].
+		</p>
+
+		<h3>[method:this lerpVectors]( [param:Vector2 v1], [param:Vector2 v2], [param:Float alpha] )</h3>
+		<p>
+		[page:Vector2 v1] - il [page:Vector2] iniziale.<br />
+		[page:Vector2 v2] - [page:Vector2] verso cui interpolare.<br />
+		[page:Float alpha] - fattore interpolazione, tipicamente nell'intervallo chiuso `[0, 1]`.<br /><br />
+
+		Imposta questo vettore per essere il vettore lineare interpolato tra [page:Vector2 v1] e
+		[page:Vector2 v2] dove alfa è la distanza percentuale lungo la linea che collega i due vettori
+		- alfa = 0 sarà [page:Vector2 v1] e alfa = 1 sarà [page:Vector2 v].
+		</p>
+
+		<h3>[method:this negate]()</h3>
+		<p>Inverte questo vettore - cioè imposta x = -x e y = -y.</p>
+
+		<h3>[method:this normalize]()</h3>
+		<p>
+			Converte questo vettore ad un [link:https://en.wikipedia.org/wiki/Unit_vector vettore unitario] - cioè, lo imposta uguale 
+			ad un vettore con la stessa direzione di questo, ma con [page:.length lunghezza] 1.
+		</p>
+
+		<h3>[method:this max]( [param:Vector2 v] )</h3>
+		<p>
+			Se il valore x o y di questo vettore è minore del valore x o y di [page:Vector2 v], sostituisce
+			questo valore con il valore massimo corrispondente.
+		</p>
+
+		<h3>[method:this min]( [param:Vector2 v] )</h3>
+		<p>
+			Se il valore x o y di questo vettore è maggiore del valore x o y di [page:Vector2 v], sostituisce
+			questo valore con il valore minimo corrispondente.
+		</p>
+
+		<h3>[method:this multiply]( [param:Vector2 v] )</h3>
+		<p>Moltiplica questo vettore per [page:Vector2 v].</p>
+
+
+		<h3>[method:this multiplyScalar]( [param:Float s] )</h3>
+		<p>Moltiplica questo vettore per lo scalare [page:Float s].</p>
+
+		<h3>[method:this rotateAround]( [param:Vector2 center], [param:Float angle] )</h3>
+		<p>
+			[page:Vector2 center] - il punto attorno al quale ruotare.<br />
+			[page:Float angle] - l'angolo di rotazione, in radianti.<br /><br />
+
+			Ruota questo vettore attorno al [page:Vector2 centro] di un [page:Float angolo] in radianti.
+		</p>
+
+		<h3>[method:this round]()</h3>
+		<p>I componenti di questo vettore vengono arrotondati al valore intero più vicino.</p>
+
+		<h3>[method:this roundToZero]()</h3>
+		<p>
+			I componenti di questo vettore vengono arrotondati per difetto (per eccesso se negativo, per difetto se positivo) a un valore intero.
+		</p>
+
+		<h3>[method:this set]( [param:Float x], [param:Float y] )</h3>
+		<p>Imposta i componenti [page:.x x] e [page:.y y] di questo.</p>
+
+		<h3>[method:this setComponent]( [param:Integer index], [param:Float value] )</h3>
+		<p>
+		[page:Integer index] - 0 o 1.<br />
+		[page:Float value] - [page:Float]<br /><br />
+
+		Se l'indice è uguale a 0 imposta [page:.x x] a [page:Float value]. <br />
+		Se l'indice è uguale a 1 imposta [page:.y y] a [page:Float value]. <br />
+		</p>
+
+		<h3>[method:this setLength]( [param:Float l] )</h3>
+		<p>
+			Imposta questo vettore ad un vettore con la stessa direzione di questo, ma con [page:.length lunghezza]
+			[page:Float l].
+		</p>
+
+		<h3>[method:this setScalar]( [param:Float scalar] )</h3>
+		<p>
+			Imposta i valori [page:.x x] e [page:.y y] di questo vettore entrambi uguali allo [page:Float scalare].
+		</p>
+
+		<h3>[method:this setX]( [param:Float x] )</h3>
+		<p>Sostuisce il valore di [page:.x x] di questo vettore con [page:Float x].</p>
+
+		<h3>[method:this setY]( [param:Float y] )</h3>
+		<p>Sostuisce il valore di [page:.y y] di questo vettore con [page:Float y].</p>
+
+		<h3>[method:this sub]( [param:Vector2 v] )</h3>
+		<p>Sottrae [page:Vector2 v] da questo vettore.</p>
+
+		<h3>[method:this subScalar]( [param:Float s] )</h3>
+		<p>Sottrae [page:Float s] dai componenti [page:.x x] e [page:.y y] di questo vettore.</p>
+
+		<h3>[method:this subVectors]( [param:Vector2 a], [param:Vector2 b] )</h3>
+		<p>Imposta questo vettore a [page:Vector2 a] - [page:Vector2 b].</p>
+
+		<h3>[method:Array toArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - (opzionale) array in cui memorizzare questo vettore. Se non viene fornito, verrà creato un nuovo array.<br />
+		[page:Integer offset] - (opzionale) offset opzionale nell'array.<br /><br />
+
+		Restituisce un array [x, y], o copia x e y nell'[page:Array array] fornito.
+		</p>
+
+		<h3>[method:this random]()</h3>
+		<p>
+			Imposta ogni componente di questo vettore ad un valore pseudo-random tra 0 e 1, escludendo 1.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Vector3.html

@@ -0,0 +1,467 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Classe che rappresenta un [link:https://en.wikipedia.org/wiki/Vector_space vettore] 3D.
+
+			Un vettore 3D è una tripletta ordinata di numeri (etichettati con x, y e z), che può essere
+			utilizzata per rappresentare una serie di cose, come:
+		</p>
+
+		<ul>
+			<li>
+				Un punto nello spazio 3D.
+			</li>
+			<li>
+				Una direzione e lunghezza nello spazio 3D. In three.js la lunghezza sarà sempre la 
+				[link:https://en.wikipedia.org/wiki/Euclidean_distance distanza Euclidea]
+				(distanza in liena retta) da `(0, 0, 0)` a `(x, y, z)` e anche la direzione viene misurata da
+				`(0, 0, 0)` verso `(x, y, z)`.
+			</li>
+			<li>
+				Qualsiasi tripletta di numeri ordinata arbitrariamente.
+			</li>
+		</ul>
+
+		<p>
+			Ci sono altre cose che possono essere rappresentate da un vettore 3D, come i vettori 
+			di quantità di moto e così via, tuttavia questi sono gli usi comuni in three.js.
+		</p>
+
+		<p>
+			L'iterazione di un'istanza [name] produrrà i suoi componenti `(x, y, z)` nell'ordine corrispondente.
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const a = new THREE.Vector3( 0, 1, 0 );
+
+		// nessun argomento; sarà inizializzato a (0, 0, 0)
+		const b = new THREE.Vector3( );
+
+		const d = a.distanceTo( b );
+		</code>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( [param:Float x], [param:Float y], [param:Float z] )</h3>
+		<p>
+		[page:Float x] - il valore x di questo vettore. Il valore predefinito è `0`.<br />
+		[page:Float y] - il valore y di questo vettore. Il valore predefinito è `0`.<br />
+		[page:Float z] - il valore z di questo vettore. Il valore predefinito è `0`.<br /><br />
+
+		Crea un nuovo [name].
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Boolean isVector3]</h3>
+		<p>
+			Flag di sola lettura per verificare che l'oggetto dato sia di tipo [name].
+		</p>
+
+		<h3>[property:Float x]</h3>
+
+		<h3>[property:Float y]</h3>
+
+		<h3>[property:Float z]</h3>
+
+
+		<h2>Metodi</h2>
+
+		<h3>[method:this add]( [param:Vector3 v] )</h3>
+		<p>Aggiunge [page:Vector3 v] a questo vettore.</p>
+
+		<h3>[method:this addScalar]( [param:Float s] )</h3>
+		<p>Aggiunge il valore scalare [page:Float s] ai valori [page:.x x], [page:.y y] e [page:.z z] di questo vettore.</p>
+
+		<h3>[method:this addScaledVector]( [param:Vector3 v], [param:Float s] )</h3>
+		<p>Aggiunge il multiplo di [page:Vector3 v] e [page:Float s] a questo vettore.</p>
+
+		<h3>[method:this addVectors]( [param:Vector3 a], [param:Vector3 b] )</h3>
+		<p>Imposta questo vettore a [page:Vector3 a] + [page:Vector3 b].</p>
+
+		<h3>[method:this applyAxisAngle]( [param:Vector3 axis], [param:Float angle] )</h3>
+		<p>
+		[page:Vector3 axis] - Un [page:Vector3] normalizzato.<br />
+		[page:Float angle] - Un angolo in radianti.<br /><br />
+
+		Applica una rotazione specifica da un asse e un angolo a questo vettore.
+		</p>
+
+		<h3>[method:this applyEuler]( [param:Euler euler] )</h3>
+		<p>
+			Applica la trasformazione di Eulero a questo vettore convertendo l'oggetto [page:Euler Eulero]
+			a un [page:Quaternion Quaternione] e applicandolo.
+		</p>
+
+		<h3>[method:this applyMatrix3]( [param:Matrix3 m] )</h3>
+		<p>Moltiplica questo vettore per [page:Matrix3 m]</p>
+
+		<h3>[method:this applyMatrix4]( [param:Matrix4 m] )</h3>
+		<p>
+			Moltiplica questo vettore (con un 1 implicito come quarto componente) per m, e divide per prospettiva.
+		</p>
+
+		<h3>[method:this applyNormalMatrix]( [param:Matrix3 m] )</h3>
+		<p>Moltiplica questo vettore per la matrice normale [page:Matrix3 m] e normalizza il risultato.</p>
+
+		<h3>[method:this applyQuaternion]( [param:Quaternion quaternion] )</h3>
+		<p>
+			Applica una trasformata [page:Quaternion Quaternione] a questo vettore.
+		</p>
+
+
+		<h3>[method:Float angleTo]( [param:Vector3 v] )</h3>
+		<p>
+			Restituisce l'angolo tra questo vettore e il vettore [page:Vector3 v] in radianti.
+		</p>
+
+		<h3>[method:this ceil]()</h3>
+		<p>
+			I componenti [page:.x x], [page:.y y] e [page:.z z] di questo vettore vengono arrotondati per eccesso al valore intero più vicino.
+		</p>
+
+		<h3>[method:this clamp]( [param:Vector3 min], [param:Vector3 max] )</h3>
+		<p>
+		[page:Vector3 min] - i valori minimi [page:.x x], [page:.y y] e [page:.z z].<br />
+		[page:Vector3 max] - i valori massimi [page:.x x], [page:.y y] e [page:.z z] nell'intervallo desiderato.<br /><br />
+
+		Se il valore x, y o z di questo vettore è maggiore del valore di x, y o z del vettore massimo, verrà sostuito dal corrispondente valore.<br /><br />
+		Se il valore x, y o z di questo vettore è minore del valore di x, y o z del vettore minimo, verrà sostuito dal corrispondente valore.
+		</p>
+
+		<h3>[method:this clampLength]( [param:Float min], [param:Float max] )</h3>
+		<p>
+		[page:Float min] - il valore minimo a cui verrà fissata la lunghezza. <br />
+		[page:Float max] - il valore massimo a cui verrà fissata la lunghezza.<br /><br />
+
+		Se la lunghezza di questo vettore è maggiore del valore massimo, il vettore verrà sostituito in modo che la sua lunghezza sia il valore massimo.<br /><br />
+		Se la lunghezza di questo vettore è minore del valore minimo, il vettore verrà sostituito in modo che la sua lunghezza sia il valore minimo.
+		</p>
+
+		<h3>[method:this clampScalar]( [param:Float min], [param:Float max] )</h3>
+		<p>
+		[page:Float min] - il valore minimo a cui verranno fissati i componenti.<br />
+		[page:Float max] - il valore massimo a cui verranno fissati i componenti.<br /><br />
+
+		Se i valori di x, y o z di questo vettore sono maggiori del valore massimo, verranno sostuiti dal valore massimo.<br /><br />
+		Se i valori di x, y o z di questo vettore sono minori del valore minimo, verranno sostuiti dal valore minimo.
+		</p>
+
+		<h3>[method:Vector3 clone]()</h3>
+		<p>
+			Restituisce un nuovo Vector3 con gli stessi valori [page:.x x], [page:.y y] e [page:.z z] di questo.
+		</p>
+
+		<h3>[method:this copy]( [param:Vector3 v] )</h3>
+		<p>
+			Copia i valori delle proprietà [page:.x x], [page:.y y] e [page:.z z] del vettore passato in questo vettore.
+		</p>
+
+		<h3>[method:this cross]( [param:Vector3 v] )</h3>
+		<p>
+			Imposta questo vettore come [link:https://en.wikipedia.org/wiki/Cross_product prodotto vettoriale] di se stesso e [page:Vector3 v].
+		</p>
+
+		<h3>[method:this crossVectors]( [param:Vector3 a], [param:Vector3 b] )</h3>
+		<p>
+			Imposta questo vettore come [link:https://en.wikipedia.org/wiki/Cross_product prodotto vettoriale] di [page:Vector3 a] e [page:Vector3 b].
+		</p>
+
+		<h3>[method:Float distanceTo]( [param:Vector3 v] )</h3>
+		<p>Calcola la distanza da questo vettore e [page:Vector3 v].</p>
+
+		<h3>[method:Float manhattanDistanceTo]( [param:Vector3 v] )</h3>
+		<p>
+			Calcola la [link:https://en.wikipedia.org/wiki/Taxicab_geometry distanza Manhattan] tra questo vettore e [page:Vector3 v].
+		</p>
+
+		<h3>[method:Float distanceToSquared]( [param:Vector3 v] )</h3>
+		<p>
+			Calcola la distanza al quadrato da questo vettore a [page:Vector3 v]. Se stai semplicemente
+			confrontando la distanza con un'altra distanza, dovresti invece confrontare la distanza al quadrato
+			poiché è leggermente più efficiente da calcolare.
+		</p>
+
+		<h3>[method:this divide]( [param:Vector3 v] )</h3>
+		<p>Divide questo vettore per [page:Vector3 v].</p>
+
+		<h3>[method:this divideScalar]( [param:Float s] )</h3>
+		<p>
+			Divide questo vettore per lo scalare [page:Float s].
+		</p>
+
+		<h3>[method:Float dot]( [param:Vector3 v] )</h3>
+		<p>
+			Calcola il [link:https://en.wikipedia.org/wiki/Dot_product prodotto scalare] di questo vettore e
+			[page:Vector3 v].
+		</p>
+
+		<h3>[method:Boolean equals]( [param:Vector3 v] )</h3>
+		<p>Restituisce `true` se i componenti di questo vettore e [page:Vector3 v] sono strettamente uguali; `false` altrimenti.</p>
+
+		<h3>[method:this floor]()</h3>
+		<p>I componenti di questo vettore vengono arrotondati per difetto al valore intero più vicino.</p>
+
+		<h3>[method:this fromArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - l'array sorgente.<br />
+		[page:Integer offset] - (opzionale) l'offset nell'array. Il valore predefinito è 0.<br /><br />
+
+		Imposta il valore [page:.x x] di questo vettore su `array[ offset + 0 ]`, il valore [page:.y y] su `array[ offset + 1 ]`
+		e il valore [page:.z z] su `array[ offset + 2 ]`.
+		</p>
+
+		<h3>[method:this fromBufferAttribute]( [param:BufferAttribute attribute], [param:Integer index] )</h3>
+		<p>
+		[page:BufferAttribute attribute] - l'attributo sorgente.<br />
+		[page:Integer index] - l'indice nell'attributo.<br /><br />
+
+		Imposta i valori [page:.x x], [page:.y y] e [page:.z z] di questo vettore nell'[page:BufferAttribute attributo].
+		</p>
+
+		<h3>[method:Float getComponent]( [param:Integer index] )</h3>
+		<p>
+		[page:Integer index] - 0, 1 o 2.<br /><br />
+
+		Se l'indice è uguale a 0 restituisce il valore [page:.x x]. <br />
+		Se l'indice è uguale a 1 restituisce il valore [page:.y y]. <br />
+		Se l'indice è uguale a 2 restituisce il valore [page:.z z].
+		</p>
+
+		<h3>[method:Float length]()</h3>
+		<p>Calcola la [link:https://en.wikipedia.org/wiki/Euclidean_distance lunghezza Euclidea]
+		(lunghezza in linea retta) da (0, 0, 0) a (x, y, z).</p>
+
+		<h3>[method:Float manhattanLength]()</h3>
+		<p>
+			Calcola la [link:http://en.wikipedia.org/wiki/Taxicab_geometry lunghezza Manhattan] di questo vettore.
+		</p>
+
+		<h3>[method:Float lengthSq]()</h3>
+		<p>
+			Calcola il quadrato della [link:https://en.wikipedia.org/wiki/Euclidean_distance lunghezza Euclidea]
+			(lunghezza in linea retta) da (0, 0, 0) a (x, y, z). Se stai comparando le lunghezze dei vettori, dovresti invece
+			confrontare la lunghezza quadrata poiché è leggermente più efficiente da calcolare.
+		</p>
+
+		<h3>[method:this lerp]( [param:Vector3 v], [param:Float alpha] )</h3>
+		<p>
+		[page:Vector3 v] - [page:Vector3] verso in cui interpolare.<br />
+		[page:Float alpha] - fattore di interpolazione, tipicamente nell'intervallo chiuso `[0, 1]`.<br /><br />
+
+		Interpola linearmente tra questo vettore e [page:Vector3 v], dove alfa è la distanza percentuale
+		lungo la linea - alfa = 0 sarà questo vettore e alfa = 1 sarà [page:Vector3 v].
+		</p>
+
+		<h3>[method:this lerpVectors]( [param:Vector3 v1], [param:Vector3 v2], [param:Float alpha] )</h3>
+		<p>
+		[page:Vector3 v1] - il [page:Vector3] iniziale.<br />
+		[page:Vector3 v2] - [page:Vector3] verso cui interpolare.<br />
+		[page:Float alpha] - fattore di interpolazione, tipicamente nell'intervallo chiuso `[0, 1]`.<br /><br />
+
+		Imposta questo vettore per essere il vettore lineare interpolato tra [page:Vector3 v1] e
+		[page:Vector3 v2] dove alfa è la distanza percentuale lungo la linea che collega i due vettori
+		- alfa = 0 sarà [page:Vector3 v1] e alfa = 1 sarà [page:Vector3 v2].
+		</p>
+
+		<h3>[method:this max]( [param:Vector3 v] )</h3>
+		<p>
+			Se il valore x, y o z di questo vettore è minore del valore x, y o z di [page:Vector3 v], sostituisce
+			questo valore con il valore massimo corrispondente.
+		</p>
+
+		<h3>[method:this min]( [param:Vector3 v] )</h3>
+		<p>
+			Se il valore x, y o z di questo vettore è maggiore del valore x, y o z di [page:Vector3 v], sostituisce
+			questo valore con il valore minimo corrispondente.
+		</p>
+
+		<h3>[method:this multiply]( [param:Vector3 v] )</h3>
+		<p>Moltiplica questo vettore per [page:Vector3 v].</p>
+
+		<h3>[method:this multiplyScalar]( [param:Float s] )</h3>
+		<p>Moltiplica questo vettore per lo scalare [page:Float s].</p>
+
+		<h3>[method:this multiplyVectors]( [param:Vector3 a], [param:Vector3 b] )</h3>
+		<p>Imposta questo vettore uguale a [page:Vector3 a] * [page:Vector3 b], dal punto di vista dei componenti.</p>
+
+		<h3>[method:this negate]()</h3>
+		<p>Inverte questo vettore - cioè imposta x = -x, y = -y e z = -z.</p>
+
+		<h3>[method:this normalize]()</h3>
+		<p>
+			Converte questo vettore in un [link:https://en.wikipedia.org/wiki/Unit_vector vettore unitario] - cioè, lo imposta uguale ad un vettore 
+			con la stessa direzione di questo, ma con [page:.length lunghezza] 1.
+		</p>
+
+		<h3>[method:this project]( [param:Camera camera] )</h3>
+		<p>
+		[page:Camera camera] — telecamera da utilizzare nella proiezione.<br /><br />
+
+		Proietta questo vettore dallo spazio world nello spazio delle coordinate normalizzate del dispositivo (NDC) della telecamera. 
+		</p>
+
+		<h3>[method:this projectOnPlane]( [param:Vector3 planeNormal] )</h3>
+		<p>
+		[page:Vector3 planeNormal] - Un vettore che rappresenta un piano normale.<br /><br />
+
+		[link:https://en.wikipedia.org/wiki/Vector_projection Proietta] questo vettore su un piano sottraendo 
+		questo vettore proiettato sulla normale del piano da questo vettore.
+		</p>
+
+		<h3>[method:this projectOnVector]( [param:Vector3 v] )</h3>
+		<p>[link:https://en.wikipedia.org/wiki/Vector_projection Proietta] questo vettore in [page:Vector3 v].</p>
+
+		<h3>[method:this reflect]( [param:Vector3 normal] )</h3>
+		<p>
+		[page:Vector3 normal] - la normale al piano riflettente.<br /><br />
+
+		Riflette questo vettore fuori dal piano ortogonale alla [page:Vector3 normale]. Si suppone che la normale
+		abbia lunghezza unitaria.
+		</p>
+
+		<h3>[method:this round]()</h3>
+		<p>I componenti di questo vettore vengono arrotondati al valore intero più vicino.</p>
+
+		<h3>[method:this roundToZero]()</h3>
+		<p>
+			I componenti di questo vettore vengono arrotondati verso zero (per eccesso se negativo, per difetto se positivo) a un valore intero.
+		</p>
+
+		<h3>[method:this set]( [param:Float x], [param:Float y], [param:Float z] )</h3>
+		<p>Imposta i componenti [page:.x x], [page:.y y] e [page:.z z] di questo vettore.</p>
+
+		<h3>[method:this setComponent]( [param:Integer index], [param:Float value] )</h3>
+		<p>
+		[page:Integer index] - 0, 1 o 2.<br />
+		[page:Float value] - [page:Float]<br /><br />
+
+		Se l'indice è uguale a 0 imposta [page:.x x] a [page:Float value]. <br />
+		Se l'indice è uguale a 1 imposta [page:.y y] a [page:Float value]. <br />
+		Se l'indice è uguale a 2 imposta [page:.z z] a [page:Float value].
+		</p>
+
+		<h3>[method:this setFromCylindrical]( [param:Cylindrical c] )</h3>
+		<p>
+			Imposta questo vettore dalle coordinate cilindriche [page:Cylindrical c].
+		</p>
+
+		<h3>[method:this setFromCylindricalCoords]( [param:Float radius], [param:Float theta], [param:Float y] )</h3>
+		<p>Imposta questo vettore dalle coordinate cilindriche [page:Cylindrical radius], [page:Cylindrical theta] and [page:Cylindrical y].</p>
+
+		<h3>[method:this setFromEuler]( [param:Euler euler] )</h3>
+		<p>
+			Imposta i componenti [page:.x x], [page:.y y] e [page:.z z] di questo vettore dai componenti x, y, e z 
+			dell'[page:Euler angolo di Eulero] specificato.
+		</p>
+
+		<h3>[method:this setFromMatrixColumn]( [param:Matrix4 matrix], [param:Integer index] )</h3>
+		<p>
+			Imposta i componenti [page:.x x], [page:.y y] e [page:.z z] di questo vettore dalla colonna [page:Integer indice] della [page:Matrix4 matrice].
+		</p>
+
+		<h3>[method:this setFromMatrix3Column]( [param:Matrix3 matrix], [param:Integer index] )</h3>
+		<p>
+			Imposta i componenti [page:.x x], [page:.y y] e [page:.z z] di questo vettore dalla colonna [page:Integer indice] della [page:Matrix4 matrice].
+		</p>
+
+		<h3>[method:this setFromMatrixPosition]( [param:Matrix4 m] )</h3>
+		<p>
+			Imposta questo vettore sugli elementi di posizione della 
+			[link:https://en.wikipedia.org/wiki/Transformation_matrix matrice di trasformazione] [page:Matrix4 m].
+		</p>
+
+		<h3>[method:this setFromMatrixScale]( [param:Matrix4 m] )</h3>
+		<p>
+			Imposta questo vettore sugli elementi scale della 
+			[link:https://en.wikipedia.org/wiki/Transformation_matrix matrice di trasformazione] [page:Matrix4 m].
+		</p>
+
+		<h3>[method:this setFromSpherical]( [param:Spherical s] )</h3>
+		<p>
+			Imposta questo vettore dalle coordinate sferiche [page:Spherical s].
+		</p>
+
+		<h3>[method:this setFromSphericalCoords]( [param:Float radius], [param:Float phi], [param:Float theta] )</h3>
+		<p>Imposta questo vettore dalle coordinate sferiche [page:Spherical radius], [page:Spherical phi] e [page:Spherical theta].</p>
+
+		<h3>[method:this setLength]( [param:Float l] )</h3>
+		<p>
+			Imposta questo vettore ad un vettore con la stessa direzione di questo, ma con la [page:.length lunghezza]
+			[page:Float l].
+		</p>
+
+		<h3>[method:this setScalar]( [param:Float scalar] )</h3>
+		<p>
+			Imposta i valori [page:.x x], [page:.y y] e [page:.z z] di questo vettore tutti ugualmente allo [page:Float scalare].
+		</p>
+
+		<h3>[method:this setX]( [param:Float x] )</h3>
+		<p>Sostuisce il valore [page:.x x] di questo vettore con [page:Float x].</p>
+
+		<h3>[method:this setY]( [param:Float y] )</h3>
+		<p>Sostuisce il valore [page:.y y] di questo vettore con [page:Float y].</p>
+
+		<h3>[method:this setZ]( [param:Float z] )</h3>
+		<p>Sostuisce il valore [page:.z z] di questo vettore con [page:Float z].</p>
+
+		<h3>[method:this sub]( [param:Vector3 v] )</h3>
+		<p>Sottrae [page:Vector3 v] da questo vettore.</p>
+
+		<h3>[method:this subScalar]( [param:Float s] )</h3>
+		<p>Sottrae [page:Float s] dai componenti [page:.x x], [page:.y y] e [page:.z z] di questo vettore.</p>
+
+		<h3>[method:this subVectors]( [param:Vector3 a], [param:Vector3 b] )</h3>
+		<p>Imposta questo vettore a [page:Vector3 a] - [page:Vector3 b].</p>
+
+		<h3>[method:Array toArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - (opzionale) array per memorizzare questo vettore. Se non viene fornito, verrà creato un nuovo array.<br />
+		[page:Integer offset] - (opzionale) offset opzionale nell'array.<br /><br />
+
+		Restituisce un array [x, y, z], o copia x, y e z nell'[page:Array array] fornito.
+		</p>
+
+		<h3>[method:this transformDirection]( [param:Matrix4 m] )</h3>
+		<p>
+			Trasforma la direzione di questo vettore da una matrice (3 x 3 in alto a sinistra sottoinsieme di [page:Matrix4 m])
+			e [page:.normalize normalizza] il risultato.
+		</p>
+
+		<h3>[method:this unproject]( [param:Camera camera] )</h3>
+		<p>
+		[page:Camera camera] — telecamera da usare nella proiezione.<br /><br />
+
+		Proietta questo vettore dallo spazio delle coordinate normalizzate del dispositivo (NDC) della telecamera nello spazio world. 
+		</p>
+
+		<h3>[method:this random]()</h3>
+		<p>
+			Imposta ogni componente di questo vettore ad un valore pseudo random tra 0 e 1, escludendo 1.
+		</p>
+
+		<h3>[method:this randomDirection]()</h3>
+		<p>
+			Imposta questo vettore su un punto uniformemente casuale su una sfera unitaria.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/Vector4.html

@@ -0,0 +1,348 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Classe che rappresenta un [link:https://en.wikipedia.org/wiki/Vector_space vettore] 4D.
+
+			Un vettore 4D è una quadrupla ordinata di numeri (etichettati con x, y, z e w), che può essere
+			utilizzata per rappresentare una serie di cose, come:
+		</p>
+
+		<ul>
+			<li>
+				Un punto nello spazio 4D.
+			</li>
+			<li>
+				Una direzione e lunghezza nello spazio 4D. In three.js la lunghezza sarà sempre la 
+				[link:https://en.wikipedia.org/wiki/Euclidean_distance distanza Euclidea]
+				(distanza in liena retta) da `(0, 0, 0, 0)` a `(x, y, z, w)` e anche la direzione viene misurata da
+				`(0, 0, 0, 0)` verso `(x, y, z, w)`.
+			</li>
+			<li>
+				Qualsiasi quadrupla di numeri ordinata arbitrariamente.
+			</li>
+		</ul>
+
+		<p>
+			Ci sono altre cose che possono essere rappresentate da un vettore 4D, tuttavia questi sono gli usi più comuni in *three.js*.
+		</p>
+
+		<p>
+			L'iterazione di un'istanza [name] produrrà i suoi componenti `(x, y, z, w)` nell'ordine corrispondente.
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const a = new THREE.Vector4( 0, 1, 0, 0 );
+
+		// nessun argomento; sarà inizializzato a (0, 0, 0, 1)
+		const b = new THREE.Vector4( );
+
+		const d = a.dot( b );
+		</code>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( [param:Float x], [param:Float y], [param:Float z], [param:Float w] )</h3>
+		<p>
+		[page:Float x] - il valore x di questo vettore. Il valore predefinito è `0`.<br />
+		[page:Float y] - il valore y di questo vettore. Il valore predefinito è `0`.<br />
+		[page:Float z] - il valore z di questo vettore. Il valore predefinito è `0`.<br />
+		[page:Float w] - il valore w di questo vettore. Il valore predefinito è `1`.<br /><br />
+
+		Crea un nuovo [name].
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Boolean isVector4]</h3>
+		<p>
+			Flag di sola lettura per verificare che l'oggetto dato sia di tipo [name].
+		</p>
+
+		<h3>[property:Float x]</h3>
+
+		<h3>[property:Float y]</h3>
+
+		<h3>[property:Float z]</h3>
+
+		<h3>[property:Float w]</h3>
+
+		<h3>[property:Float width]</h3>
+		<p>Alias per [page:.z z].</p>
+
+		<h3>[property:Float height]</h3>
+		<p>Alias per [page:.w w].</p>
+
+
+		<h2>Metodi</h2>
+
+		<h3>[method:this add]( [param:Vector4 v] )</h3>
+		<p>Aggiunge [page:Vector4 v] a questo vettore.</p>
+
+		<h3>[method:this addScalar]( [param:Float s] )</h3>
+		<p>Aggiunge il valore scalare [page:Float s] ai valori [page:.x x], [page:.y y], [page:.z z] e [page:.w w] di questo vettore.</p>
+
+		<h3>[method:this addScaledVector]( [param:Vector4 v], [param:Float s] )</h3>
+		<p>Aggiunge il multiplo di [page:Vector4 v] e [page:Float s] a questo vettore.</p>
+
+		<h3>[method:this addVectors]( [param:Vector4 a], [param:Vector4 b] )</h3>
+		<p>Imposta questo vettore a [page:Vector4 a] + [page:Vector4 b].</p>
+
+		<h3>[method:this applyMatrix4]( [param:Matrix4 m] )</h3>
+		<p>
+			Moltiplica questo vettore per 4 x 4 [page:Matrix4 m].
+		</p>
+
+		<h3>[method:this ceil]()</h3>
+		<p>
+			I componenti [page:.x x], [page:.y y], [page:.z z] e [page:.w w] di questo vettore vengono arrotondati per eccesso al valore intero più vicino.
+		</p>
+
+		<h3>[method:this clamp]( [param:Vector4 min], [param:Vector4 max] )</h3>
+		<p>
+		[page:Vector4 min] - i valori minimi [page:.x x], [page:.y y], [page:.z z] e [page:.w w].<br />
+		[page:Vector4 max] - i valori massimi [page:.x x], [page:.y y], [page:.z z] e [page:.w w] nell'intervallo desiderato<br /><br />
+
+		Se il valore x, y, z o w di questo vettore è maggiore del valore di x, y, z o w del vettore massimo, verrà sostuito dal corrispondente valore.<br /><br />
+		Se il valore x, y, z o w di questo vettore è minore del valore di x, y, z o w del vettore minimo, verrà sostuito dal corrispondente valore.
+		</p>
+
+		<h3>[method:this clampLength]( [param:Float min], [param:Float max] )</h3>
+		<p>
+		[page:Float min] - il valore minimo a cui verrà fissata la lunghezza. <br />
+		[page:Float max] - il valore massimo a cui verrà fissata la lunghezza.<br /><br />
+
+		Se la lunghezza di questo vettore è maggiore del valore massimo, il vettore verrà sostituito dal valore massimo.<br /><br />
+		Se la lunghezza di questo vettore è minore del valore minimo, il vettore verrà sostituito dal valore minimo.
+		</p>
+
+		<h3>[method:this clampScalar]( [param:Float min], [param:Float max] )</h3>
+		<p>
+		[page:Float min] - il valore minimo a cui verranno fissati i componenti.<br />
+		[page:Float max] - il valore massimo a cui verranno fissati i componenti.<br /><br />
+
+		Se i valori di x, y, z o w di questo vettore sono maggiori del valore massimo, verranno sostuiti dal valore massimo.<br /><br />
+		Se i valori di x, y, z o w di questo vettore sono minori del valore minimo, verranno sostuiti dal valore minimo.
+		</p>
+
+		<h3>[method:Vector4 clone]()</h3>
+		<p>
+			Restituisce un nuovo Vector4 con gli stessi valori [page:.x x], [page:.y y], [page:.z z] e [page:.w w] di questo.
+		</p>
+
+		<h3>[method:this copy]( [param:Vector4 v] )</h3>
+		<p>
+			Copia i valori delle proprietà [page:.x x], [page:.y y], [page:.z z] e [page:.w w] del vettore passato in questo vettore Vector4.
+		</p>
+
+		<h3>[method:this divideScalar]( [param:Float s] )</h3>
+		<p>
+			Divide questo vettore per lo scalare [page:Float s].
+		</p>
+
+		<h3>[method:Float dot]( [param:Vector4 v] )</h3>
+		<p>
+			Calcola il [link:https://en.wikipedia.org/wiki/Dot_product prodotto scalare] di questo vettore e
+			[page:Vector4 v].
+		</p>
+
+		<h3>[method:Boolean equals]( [param:Vector4 v] )</h3>
+		<p>Restituisce `true` se i componenti di questo vettore e [page:Vector4 v] sono strettamente uguali; `false` altrimenti.</p>
+
+		<h3>[method:this floor]()</h3>
+		<p>I componenti di questo vettore vengono arrotondati per difetto al valore intero più vicino.</p>
+
+		<h3>[method:this fromArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+		[page:Array array] - l'array sorgente.<br />
+		[page:Integer offset] - (opzionale) l'offset nell'array. Il valore predefinito è 0.<br /><br />
+
+		Imposta il valore [page:.x x] di questo vettore su `array[ offset + 0 ]`, il valore [page:.y y] su `array[ offset + 1 ]`,
+		il valore [page:.z z] su `array[ offset + 2 ]` e il valore [page:.w w] su `array[ offset + 3 ]`.
+		</p>
+
+		<h3>[method:this fromBufferAttribute]( [param:BufferAttribute attribute], [param:Integer index] )</h3>
+		<p>
+		[page:BufferAttribute attribute] - l'attributo sorgente.<br />
+		[page:Integer index] - l'indice nell'attributo.<br /><br />
+
+		Imposta i valori [page:.x x], [page:.y y], [page:.z z] e [page:.w w] di questo vettore nell'[page:BufferAttribute attributo].
+		</p>
+
+		<h3>[method:Float getComponent]( [param:Integer index] )</h3>
+		<p>
+		[page:Integer index] - 0, 1, 2 o 3.<br /><br />
+
+		Se l'indice è uguale a 0 restituisce il valore [page:.x x]. <br />
+		Se l'indice è uguale a 1 restituisce il valore [page:.y y]. <br />
+		Se l'indice è uguale a 2 restituisce il valore [page:.z z]. <br />
+		Se l'indice è uguale a 3 restituisce il valore [page:.w w]. <br />
+		</p>
+
+		<h3>[method:Float length]()</h3>
+		<p>
+			Calcola la [link:https://en.wikipedia.org/wiki/Euclidean_distance lunghezza Euclidea]
+			(lunghezza in linea retta) da `(0, 0, 0, 0)` a `(x, y, z, w)`.
+		</p>
+
+		<h3>[method:Float manhattanLength]()</h3>
+		<p>
+			Calcola la [link:http://en.wikipedia.org/wiki/Taxicab_geometry lunghezza Manhattan] di questo vettore.
+		</p>
+
+		<h3>[method:Float lengthSq]()</h3>
+		<p>
+			Calcola il quadrato della [link:https://en.wikipedia.org/wiki/Euclidean_distance lunghezza Euclidea]
+			(lunghezza in linea retta) da `(0, 0, 0, 0)` a `(x, y, z, w)`. Se stai comparando le lunghezze dei vettori, dovresti invece
+			confrontare la lunghezza quadrata poiché è leggermente più efficiente da calcolare.
+		</p>
+
+		<h3>[method:this lerp]( [param:Vector4 v], [param:Float alpha] )</h3>
+		<p>
+		[page:Vector4 v] - [page:Vector4] verso in cui interpolare.<br />
+		[page:Float alpha] - fattore di interpolazione, tipicamente nell'intervallo chiuso `[0, 1]`.<br /><br />
+
+		Interpola linearmente tra questo vettore e [page:Vector4 v], dove alfa è la distanza percentuale
+		lungo la linea - `alpha = 0` sarà questo vettore e `alpha = 1` sarà [page:Vector4 v].
+		</p>
+
+		<h3>[method:this lerpVectors]( [param:Vector4 v1], [param:Vector4 v2], [param:Float alpha] )</h3>
+		<p>
+		[page:Vector4 v1] - il [page:Vector4] iniziale.<br />
+		[page:Vector4 v2] - [page:Vector4] verso cui interpolare.<br />
+		[page:Float alpha] - fattore di interpolazione, tipicamente nell'intervallo chiuso `[0, 1]`.<br /><br />
+
+		Imposta questo vettore per essere il vettore lineare interpolato tra [page:Vector4 v1] e
+		[page:Vector4 v2] dove alfa è la distanza percentuale lungo la linea che collega i due vettori
+		- alfa = 0 sarà [page:Vector4 v1] e alfa = 1 sarà [page:Vector4 v2].
+		</p>
+
+		<h3>[method:this negate]()</h3>
+		<p>Inverte questo vettore - cioè imposta x = -x, y = -y, z = -z e w = -w.</p>
+
+		<h3>[method:this normalize]()</h3>
+		<p>
+			Converte questo vettore in un [link:https://en.wikipedia.org/wiki/Unit_vector vettore unitario] - cioè, lo imposta uguale ad un vettore 
+			con la stessa direzione di questo, ma con [page:.length lunghezza] 1.
+		</p>
+
+		<h3>[method:this max]( [param:Vector4 v] )</h3>
+		<p>
+			Se il valore x, y, z o w di questo vettore è minore del valore x, y, z o w di [page:Vector4 v], sostituisce
+			questo valore con il valore massimo corrispondente.
+		</p>
+
+		<h3>[method:this min]( [param:Vector4 v] )</h3>
+		<p>
+			Se il valore x, y, z o w di questo vettore è maggiore del valore x, y, z o w di [page:Vector4 v], sostituisce
+			questo valore con il valore minimo corrispondente.
+		</p>
+
+		<h3>[method:this multiply]( [param:Vector4 v] )</h3>
+		<p>Moltiplica questo vettore per [page:Vector4 v].</p>
+
+		<h3>[method:this multiplyScalar]( [param:Float s] )</h3>
+		<p>Moltiplica questo vettore per lo scalare [page:Float s].</p>
+
+		<h3>[method:this round]()</h3>
+		<p>I componenti di questo vettore sono arrotondati al valore intero più vicino.</p>
+
+		<h3>[method:this roundToZero]()</h3>
+		<p>
+			I componenti di questo vettore sono arrotondati verso zero (per eccesso se negativo, per difetto se positivo) a un valore intero.
+		</p>
+
+		<h3>[method:this set]( [param:Float x], [param:Float y], [param:Float z], [param:Float w] )</h3>
+		<p>Imposta i componenti [page:.x x], [page:.y y], [page:.z z] e [page:.w w] di questo vettore.</p>
+
+		<h3>[method:this setAxisAngleFromQuaternion]( [param:Quaternion q] )</h3>
+		<p>
+			[page:Quaternion q] - un [page:Quaternione] normalizzato.<br /><br />
+
+			Imposta i componenti [page:.x x], [page:.y y] e [page:.z z] di questo vettore sull'asse
+			del quaternione e [page:.w w] all'angolo.
+		</p>
+
+		<h3>[method:this setAxisAngleFromRotationMatrix]( [param:Matrix4 m] )</h3>
+		<p>
+			[page:Matrix4 m] - una [page:Matrix4] di cui la matrice 3x3 in alto a sinistra è una matrice di rotazione pura.<br /><br />
+
+			Imposta [page:.x x], [page:.y y] e [page:.z z] all'asse di rotazione e [page:.w w] all'angolo.
+		</p>
+
+		<h3>[method:this setComponent]( [param:Integer index], [param:Float value] )</h3>
+		<p>
+		[page:Integer index] - 0, 1 o 2.<br />
+		[page:Float value] - [page:Float]<br /><br />
+
+		Se l'indice è uguale a 0 imposta [page:.x x] a [page:Float value]. <br />
+		Se l'indice è uguale a 1 imposta [page:.y y] a [page:Float value]. <br />
+		Se l'indice è uguale a 2 imposta [page:.z z] a [page:Float value]. <br />
+		Se l'indice è uguale a 3 imposta [page:.w w] a [page:Float value]. <br />
+		</p>
+
+
+		<h3>[method:this setLength]( [param:Float l] )</h3>
+		<p>
+			Imposta questo vettore ad un vettore con la stessa direzione di questo, ma con la [page:.length lunghezza]
+			[page:Float l].
+		</p>
+
+		<h3>[method:this setScalar]( [param:Float scalar] )</h3>
+		<p>
+			Imposta i valori [page:.x x], [page:.y y], [page:.z z] e [page:.w w] di questo vettore tutti ugualmente allo [page:Float scalare].
+		</p>
+
+		<h3>[method:this setX]( [param:Float x] )</h3>
+		<p>Sostuisce il valore [page:.x x] di questo vettore con [page:Float x].</p>
+
+		<h3>[method:this setY]( [param:Float y] )</h3>
+		<p>Sostuisce il valore [page:.y y] di questo vettore con [page:Float y].</p>
+
+		<h3>[method:this setZ]( [param:Float z] )</h3>
+		<p>Sostuisce il valore [page:.z z] di questo vettore con [page:Float z].</p>
+
+		<h3>[method:this setW]( [param:Float w] )</h3>
+		<p>Sostuisce il valore [page:.w w] di questo vettore con [page:Float w].</p>
+
+		<h3>[method:this sub]( [param:Vector4 v] )</h3>
+		<p>Sottrae [page:Vector4 v] da questo vettore.</p>
+
+		<h3>[method:this subScalar]( [param:Float s] )</h3>
+		<p>Sottrae [page:Float s] dai componenti [page:.x x], [page:.y y], [page:.z z] e [page:.w w] di questo vettore.</p>
+
+		<h3>[method:this subVectors]( [param:Vector4 a], [param:Vector4 b] )</h3>
+		<p>Imposta questo vettore a [page:Vector4 a] - [page:Vector4 b].</p>
+
+		<h3>[method:Array toArray]( [param:Array array], [param:Integer offset] )</h3>
+		<p>
+			[page:Array array] - (opzionale) array per memorizzare questo vettore. Se non viene fornito, verrà creato un nuovo array.<br />
+			[page:Integer offset] - (opzionale) offset opzionale nell'array.<br /><br />
+
+			Restituisce un array [x, y, z, w], o copia x, y, z e w nell'[page:Array array] fornito.
+		</p>
+
+		<h3>[method:this random]()</h3>
+		<p>
+			Imposta ogni componente di questo vettore ad un valore pseudo random tra 0 e 1, escludendo 1.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/interpolants/CubicInterpolant.html

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Interpolant] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+const interpolant = new THREE.[name](
+		new Float32Array( 2 ),
+		new Float32Array( 2 ),
+		1,
+		new Float32Array( 1 )
+);
+
+interpolant.evaluate( 0.5 );
+		</code>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( parameterPositions, sampleValues, sampleSize, resultBuffer )</h3>
+		<p>
+		parameterPositions -- array di posizioni<br />
+		sampleValues -- array di campioni<br />
+		sampleSize -- numero di campioni<br />
+		resultBuffer -- buffer per memorizzare i risultati dell'interpolazione.<br /><br />
+		</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:null parameterPositions]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null resultBuffer]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null sampleValues]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:Object settings]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null valueSize]</h3>
+		<p>
+
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Array evaluate]( [param:Number t] )</h3>
+		<p>
+			Valuta l'interpolante alla posizione *t*.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/interpolants/DiscreteInterpolant.html

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Interpolant] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+const interpolant = new THREE.[name](
+		new Float32Array( 2 ),
+		new Float32Array( 2 ),
+		1,
+		new Float32Array( 1 )
+);
+
+interpolant.evaluate( 0.5 );
+		</code>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( parameterPositions, sampleValues, sampleSize, resultBuffer )</h3>
+		<p>
+		parameterPositions -- array di posizioni<br />
+		sampleValues -- array di campioni<br />
+		sampleSize -- numero di campioni<br />
+		resultBuffer -- buffer per memorizzare il risultato dell'interpolazione.<br /><br />
+		</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:null parameterPositions]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null resultBuffer]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null sampleValues]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:Object settings]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null valueSize]</h3>
+		<p>
+
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Array evaluate]( [param:Number t] )</h3>
+		<p>
+			Valuta l'interpolante alla posizione *t*.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/interpolants/LinearInterpolant.html

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Interpolant] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+const interpolant = new THREE.[name](
+		new Float32Array( 2 ),
+		new Float32Array( 2 ),
+		1,
+		new Float32Array( 1 )
+);
+
+interpolant.evaluate( 0.5 );
+		</code>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( parameterPositions, sampleValues, sampleSize, resultBuffer )</h3>
+		<p>
+		parameterPositions -- array di posizioni<br />
+		sampleValues -- array di campioni<br />
+		sampleSize -- numero di campioni<br />
+		resultBuffer -- buffer per memorizzare il risultato dell'interpolazione.<br /><br />
+		</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:null parameterPositions]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null resultBuffer]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null sampleValues]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:Object settings]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null valueSize]</h3>
+		<p>
+
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Array evaluate]( [param:Number t] )</h3>
+		<p>
+			Valuta l'interpolante alla posizione *t*.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/math/interpolants/QuaternionLinearInterpolant.html

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Interpolant] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+const interpolant = new THREE.[name](
+		new Float32Array( 2 ),
+		new Float32Array( 2 ),
+		1,
+		new Float32Array( 1 )
+);
+
+interpolant.evaluate( 0.5 );
+		</code>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( parameterPositions, sampleValues, sampleSize, resultBuffer )</h3>
+		<p>
+		parameterPositions -- array di posizioni<br />
+		sampleValues -- array di campioni<br />
+		sampleSize -- numero di campioni<br />
+		resultBuffer -- buffer per memorizzare il risultato dell'interpolazione.<br /><br />
+		</p>
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:null parameterPositions]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null resultBuffer]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null sampleValues]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:Object settings]</h3>
+		<p>
+
+		</p>
+
+		<h3>[property:null valueSize]</h3>
+		<p>
+
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Array evaluate]( [param:Number t] )</h3>
+		<p>
+			Valuta l'interpolante alla posizione *t*.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/objects/Bone.html

@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Object3D] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Un osso che è parte di uno [page:Skeleton Scheletro]. Lo scheletro a sua volta viene 
+			utilizzato da [page:SkinnedMesh]. Le ossa sono quasi identiche ad un [page:Object3D] vuoto.
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const root = new THREE.Bone();
+		const child = new THREE.Bone();
+
+		root.add( child );
+		child.position.y = 5;
+		</code>
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( )</h3>
+		<p>
+		Crea un nuovo [name].
+		</p>
+
+		<h2>Proprietà</h2>
+		<p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p>
+
+		<h3>[property:Boolean isBone]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+
+		<h3>[property:String type]</h3>
+		<p>Impostato su 'Bone', può essere utilizzato per trovare tutte le ossa in una scena.</p>
+
+
+		<h2>Metodi</h2>
+		<p>Vedi la classe base [page:Object3D] per i metodi comuni.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/objects/Group.html

@@ -0,0 +1,65 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Object3D] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Questo è quasi identico ad un [page:Object3D Object3D]. 
+			Il suo scopo è rendere sintatticamente più chiaro il lavoro con gruppi di oggetti.
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const geometry = new THREE.BoxGeometry( 1, 1, 1 );
+		const material = new THREE.MeshBasicMaterial( {color: 0x00ff00} );
+
+		const cubeA = new THREE.Mesh( geometry, material );
+		cubeA.position.set( 100, 100, 0 );
+
+		const cubeB = new THREE.Mesh( geometry, material );
+		cubeB.position.set( -100, -100, 0 );
+
+		// Crea un gruppo e aggiunge due cubi
+		// Questi cubi possono essere ruotati / ridimensionati etc come gruppo
+		const group = new THREE.Group();
+		group.add( cubeA );
+		group.add( cubeB );
+
+		scene.add( group );
+		</code>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( )</h3>
+
+		<h2>Proprietà</h2>
+		<p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p>
+
+		<h3>[property:Boolean isGroup]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h3>[property:String type]</h3>
+		<p>Una stringa 'Group'. Non deve essere modificata.</p>
+
+		<h2>Metodi</h2>
+		<p>Vedi la classe base [page:Object3D] per i metodi comuni.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/objects/InstancedMesh.html

@@ -0,0 +1,133 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Mesh] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una versione speciale di [page:Mesh] con il supporto per il rendering istanziato. Utilizza [name]
+			se devi renderizzare un grande numero di oggetti con la stessa geometria e materiale ma con 
+			diverse trasformazioni world. L'utilizzo di [name] ti aiuterà a ridurre il numero di 
+			chiamate di disegno e quindi migliorare le prestazioni complessive del rendering nell'applicazione.
+		</p>
+
+		<h2>Esempi</h2>
+
+		<p>
+			[example:webgl_instancing_dynamic WebGL / instancing / dynamic]<br />
+			[example:webgl_instancing_performance WebGL / instancing / performance]<br />
+			[example:webgl_instancing_scatter WebGL / instancing / scatter]<br />
+			[example:webgl_instancing_raycast WebGL / instancing / raycast]
+		</p>
+
+		<h2>Costruttore</h2>
+		<h3>[name]( [param:BufferGeometry geometry], [param:Material material], [param:Integer count] )</h3>
+		<p>
+		[page:BufferGeometry geometry] - un'istanza di [page:BufferGeometry].<br />
+		[page:Material material] - un'istanza di [page:Material]. Il valore di default è un nuovo [page:MeshBasicMaterial].<br />
+		[page:Integer count] - il numero di istanze.<br />
+		</p>
+
+		<h2>Proprietà</h2>
+		<p>Vedi la classe base [page:Mesh] per le proprietà comuni.</p>
+
+		<h3>[property:Integer count]</h3>
+		<p>
+			Il numero di istanze. Il valore `count` passato nel costruttore rappresenta il numero 
+			massimo di istanze di questa mesh. Puoi modificare il numero di istanze in fase di esecuzione ad un valore intero
+			nell'intervallo [0, count].
+		</p>
+		<p>
+			Se hai bisogno di più istanze del valore count originale, devi creare una nuova [name].
+		</p>
+
+		<h3>[property:InstancedBufferAttribute instanceColor]</h3>
+		<p>
+			Rappresenta i colori di tutte le istanze. Il valore predefinito è `null`.
+			È necessario impostare il suo flag [page:BufferAttribute.needsUpdate needsUpdate] 
+			a true se si modificano i dati di istanza tramite [page:.setColorAt]().
+		</p>
+
+		<h3>[property:InstancedBufferAttribute instanceMatrix]</h3>
+		<p>
+			Rappresenta la trasformazione locale di tutte le istanze.
+			È necessario impostare il suo flag [page:BufferAttribute.needsUpdate needsUpdate] 
+			a true se si modificano i dati di istanza tramite [page:.setMatrixAt]().
+		</p>
+
+		<h3>[property:Boolean isInstancedMesh]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h2>Metodi</h2>
+		<p>Vedi la classe base [page:Mesh] per i metodi comuni.</p>
+
+		<h3>[method:undefined dispose]()</h3>
+		<p>
+			Libera le risorse relative alla GPU allocate da questa istanza.
+			Chiama questo metodo ogni volta che questa istanza non è più utilizzata nella tua applicazione.
+		</p>
+
+		<h3>[method:undefined getColorAt]( [param:Integer index], [param:Color color] )</h3>
+		<p>
+			[page:Integer index]: L'indice di un'istanza. I valori devono essere nell'intervallo [0, count].
+		</p>
+		<p>
+			[page:Color color]: Il colore dell'oggetto sarà impostato al colore dell'istanza definita.
+		</p>
+		<p>
+			Ottieni il colore dell'istanza definita.
+		</p>
+
+		<h3>[method:undefined getMatrixAt]( [param:Integer index], [param:Matrix4 matrix] )</h3>
+		<p>
+			[page:Integer index]: L'indice di un'istanza. I valori devono essere nell'intervallo [0, count].
+		</p>
+		<p>
+			[page:Matrix4 matrix]: Questa matrice 4x4 sarà impostata alla matrice trasformazione locale dell'istanza definita.
+		</p>
+		<p>
+			Ottieni la matrice trasformazione locale dell'istanza definita.
+		</p>
+
+		<h3>[method:undefined setColorAt]( [param:Integer index], [param:Color color] )</h3>
+		<p>
+			[page:Integer index]: L'indice di un'istanza. I valori devono essere nell'intervallo [0, count].
+		</p>
+		<p>
+			[page:Color color]: Il colore di una singola istanza.
+		</p>
+		<p>
+			Imposta il colore dato all'istanza definita.
+			Assicurati di impostare [page:.instanceColor][page:BufferAttribute.needsUpdate .needsUpdate] 
+			a true dopo l'aggiornamento di tutti i colori.
+		</p>
+
+		<h3>[method:undefined setMatrixAt]( [param:Integer index], [param:Matrix4 matrix] )</h3>
+		<p>
+			[page:Integer index]: L'indice di un'istanza. I valori devono essere nell'intervallo [0, count].
+		</p>
+		<p>
+			[page:Matrix4 matrix]: Una matrice 4x4 che rappresenta la trasformazione locale di una singola istanza.
+		</p>
+		<p>
+			Imposta la matrice trasformazione locale data all'istanza definita.
+			Assicurati di impostare [page:.instanceColor][page:BufferAttribute.needsUpdate .needsUpdate] 
+			a true dopo l'aggiornamento di tutte le matrici.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/objects/LOD.html

@@ -0,0 +1,128 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Object3D] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Livello di Dettaglio - mostra mesh con più o meno geometria in base alla distanza dalla telecamera.<br /><br />
+
+			Ogni livello è associato ad un oggetto, e il rendering può essere commutato tra di loro alle distanze specificate.
+			In genere creeresti, per esempio, tre mesh, una per il lontano (dettaglio basse), una per la gamma media (medio dettaglio)
+			e una per i primi piani (alto dettaglio).
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const lod = new THREE.LOD();
+
+		// Crea sfere con 3 livelli di dettaglio e crea nuovi livelli LOD per loro
+		for( let i = 0; i < 3; i++ ) {
+
+			const geometry = new THREE.IcosahedronGeometry( 10, 3 - i )
+
+			const mesh = new THREE.Mesh( geometry, material );
+
+			lod.addLevel( mesh, i * 75 );
+
+		}
+
+		scene.add( lod );
+		</code>
+
+		<h2>Esempi</h2>
+
+		<p>
+			[example:webgl_lod webgl / lod ]
+		</p>
+
+		<h2>Costruttore</h2>
+		<h3>[name]( )</h3>
+		<p>
+			Crea un nuovo [name].
+		</p>
+
+		<h2>Proprietà</h2>
+		<p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p>
+
+		<h3>[property:Boolean autoUpdate]</h3>
+		<p>
+			Indica se l'oggetto LOD viene aggiornato automaticamente dal renderer per frame o no.
+			Se impostato a false, devi chiamare da solo [page:LOD.update]() nel ciclo di rendering.
+			Il valore predefinito è true.
+		</p>
+
+		<h3>[property:Boolean isLOD]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h3>[property:Array levels]</h3>
+		<p>
+			Un array di oggetti [page:Object level].<br /><br />
+
+			Ogni livello è un oggetto con due proprietà:<br />
+			[page:Object3D object] - L'[page:Object3D] da visualizzare a questo livello.<br />
+			[page:Float distance] - La distanza alla quale visualizzare questo livello di dettaglio.
+		</p>
+
+		<h2>Metodi</h2>
+		<p>Vedi la classe base [page:Object3D] per i metodi comuni.</p>
+
+		<h3>[method:this addLevel]( [param:Object3D object], [param:Float distance] )</h3>
+		<p>
+		[page:Object3D object] - L'[page:Object3D] da visualizzare a questo livello.<br />
+		[page:Float distance] - La distanza alla quale visualizzare questo livello di dettaglio.<br /><br />
+
+		Aggiunge una mesh che sarà visualizzata ad una certa distanza e maggiore. In genere, maggiore è 
+		la distanza, minore è il dettaglio sulla mesh.
+		</p>
+
+		<h3>[method:LOD clone]()</h3>
+		<p>
+			Restituisce un clone di questo oggetto LOD e degli oggetti specifici della distanza ad esso associati.
+		</p>
+
+
+		<h3>[method:Integer getCurrentLevel]()</h3>
+		<p>
+			Ottiene il livello LOD attivo attualmente. Come indice dell'array dei livelli.
+		</p>
+
+		<h3>[method:Object3D getObjectForDistance]( [param:Float distance] )</h3>
+		<p>
+			Ottiene un riferimento al primo [page:Object3D] (mesh) che è maggiore della [page:Float distance].
+		</p>
+
+		<h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
+		<p>
+			Ottiene le intersezioni tra un [page:Ray] lanciato a questo LOD.
+			[page:Raycaster.intersectObject] chiamerà questo metodo.
+		</p>
+
+		<h3>[method:Object toJSON]( meta )</h3>
+		<p>
+			Crea una struttura JSON con i dettagli di questo oggetto LOD.
+		</p>
+
+		<h3>[method:undefined update]( [param:Camera camera] )</h3>
+		<p>
+			Imposta la visibilità di ogni [page:Object3D oggetto] del [page:levels livello] in base 
+			alla distanza dalla [page:Camera telecamera].
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/objects/Line.html

@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Object3D] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una linea continua.<br /><br />
+
+			Questo è quasi lo stesso di [page:LineSegments]; l'unica differenza è che questo viene renderizzato utilizzando
+			[link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINE_STRIP]
+			invece di [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINES]
+
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const material = new THREE.LineBasicMaterial({
+			color: 0x0000ff
+		});
+
+		const points = [];
+		points.push( new THREE.Vector3( - 10, 0, 0 ) );
+		points.push( new THREE.Vector3( 0, 10, 0 ) );
+		points.push( new THREE.Vector3( 10, 0, 0 ) );
+
+		const geometry = new THREE.BufferGeometry().setFromPoints( points );
+
+		const line = new THREE.Line( geometry, material );
+		scene.add( line );
+		</code>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3>
+
+		<p>
+		[page:BufferGeometry geometry] — vertici che rappresentano il segmento(i) di linea. Il valore predefinito è una nuova [page:BufferGeometry].<br />
+		[page:Material material] — materiale per la linea. Il valore predefinito è una nuova [page:LineBasicMaterial].<br />
+		</p>
+
+		<h2>Proprietà</h2>
+		<p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p>
+
+		<h3>[property:BufferGeometry geometry]</h3>
+		<p>Vertici che rappresentano il segmento(i) di linea.</p>
+
+		<h3>[property:Boolean isLine]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h3>[property:Material material]</h3>
+		<p>Materiale per la linea.</p>
+
+		<h3>[property:Array morphTargetInfluences]</h3>
+		<p>
+			Un array di pesi solitamente da 0 a 1 che specifica la quantità di morph applicata.
+			Non definito per impostazione predefinita, ma reimpostato su un array vuoto da [page:.updateMorphTargets]().
+		</p>
+
+		<h3>[property:Object morphTargetDictionary]</h3>
+		<p>
+			Un dizionario di morphTargets basato sulla proprietà morphTarget.name.
+			Non definito per impostazione predefinita, ma ricompilato [page:.updateMorphTargets]().
+		</p>
+
+		<h2>Metodi</h2>
+		<p>Vedi la classe base [page:Object3D] per i metodi comuni.</p>
+
+		<h3>[method:this computeLineDistances]()</h3>
+		<p>
+			Calcola un array di valori di distanza necessari per [page:LineDashedMaterial]. 
+			Per ogni vertice nella geometria, il metodo calcola la lunghezza cumulativa dal punto
+			corrente fino all'inizio della linea.
+		</p>
+
+		<h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
+		<p>
+			Ottiene le intersezioni tra un [page:Ray] lanciato e questa linea.
+			[page:Raycaster.intersectObject] chiamerà questo metodo.
+		</p>
+
+		<h3>[method:Line clone]()</h3>
+		<p>
+			Restituisce un clone di questo oggetto Line e i suoi discendenti.
+		</p>
+
+		<h3>[method:undefined updateMorphTargets]()</h3>
+		<p>
+			Aggiorna i morphTargets in modo che non abbiano alcuna influenza sull'oggetto. 
+			Reimposta le proprietà [page:.morphTargetInfluences] e [page:.morphTargetDictionary].
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/objects/LineLoop.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Object3D] &rarr; [page:Line] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una linea continua che si ricollega alla partenza.<br /><br />
+
+			Questo è quasi lo stesso di [page:Line]; l'unica differenza è che viene
+			renderizzato utilizzando 
+			[link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINE_LOOP]
+			invece di [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINE_STRIP],
+			il quale disegna una linea retta al vertice successivo, e ricollega l'ultimo vertice al primo.
+		</p>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3>
+
+		<p>
+		[page:BufferGeometry geometry] — Elenco di vertici che rappresentano i punti del ciclo della linea.<br />
+		[page:Material material] — Materiale per la linea. Il valore predefinito è [page:LineBasicMaterial LineBasicMaterial].
+		</p>
+
+		<h2>Proprietà</h2>
+		<p>Vedi la classe base [page:Line] per le proprietà comuni.</p>
+
+		<h3>[property:Boolean isLineLoop]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+
+		<h2>Metodi</h2>
+		<p>Vedi la classe base [page:Line] per i metodi comuni.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/objects/LineSegments.html

@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Object3D] &rarr; [page:Line] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una serie di linee tracciate tra coppie di vertici.<br /><br />
+
+			Questo è quasi lo stesso di [page:Line]; l'unica differenza è che viene
+			renderizzato utilizzando 
+			[link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINES]
+			invece di [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINE_STRIP].
+		</p>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3>
+
+		<p>
+		[page:BufferGeometry geometry] — Coppia(e) di vertici che rappresentano ogni segmento(i) di linea.<br />
+		[page:Material material] — Materiale per la linea. Il valore predefinito è [page:LineBasicMaterial LineBasicMaterial].
+		</p>
+
+		<h2>Proprietà</h2>
+		<p>Vedi la classe base [page:Line] per le proprietà comuni.</p>
+
+		<h3>[property:Boolean isLineSegments]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+
+		<h2>Metodi</h2>
+		<p>Vedi la classe base [page:Line] per i metodi comuni.</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/objects/Mesh.html

@@ -0,0 +1,93 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Object3D] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una classe che rappresenta oggetti basati su [link:https://en.wikipedia.org/wiki/Polygon_mesh mesh poligonali] triangolari.
+			Serve anche come base per altre classi come [page:SkinnedMesh].
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const geometry = new THREE.BoxGeometry( 1, 1, 1 );
+		const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+		const mesh = new THREE.Mesh( geometry, material );
+		scene.add( mesh );
+		</code>
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3>
+		<p>
+		[page:BufferGeometry geometry] — (opzionale) un'istanza di [page:BufferGeometry]. Il valore predefinito è una nuova [page:BufferGeometry].<br />
+		[page:Material material] — (opzionale) un singolo o un array di [page:Material Material]. Il valore predefinito è una nuova [page:MeshBasicMaterial].
+		</p>
+
+		<h2>Proprietà</h2>
+		<p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p>
+
+		<h3>[property:BufferGeometry geometry]</h3>
+		<p>
+			Un'istanza di [page:BufferGeometry] (o classi derivate), che definisce la struttura dell'oggetto.
+		</p>
+
+		<h3>[property:Boolean isMesh]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h3>[property:Material material]</h3>
+		<p>
+			Un'istanza di materiale derivata dalla classe base [page:Material] o un array di materiali, che definisce
+			l'aspetto dell'oggetto. Il valore predefinito è [page:MeshBasicMaterial].
+		</p>
+
+		<h3>[property:Array morphTargetInfluences]</h3>
+		<p>
+			Un array di pesi solitamente da 0 a 1 che specifica la quantità di morph applicata.
+			Non definito per impostazione predefinita, ma reimpostato su un array vuoto da [page:Mesh.updateMorphTargets updateMorphTargets].
+		</p>
+
+		<h3>[property:Object morphTargetDictionary]</h3>
+		<p>
+			Un dizionario di morphTargets basato sulla proprietà morphTarget.name.
+			Non definito per impostazione predefinita, ma ricompilato [page:Mesh.updateMorphTargets updateMorphTargets].
+		</p>
+
+		<h2>Metodi</h2>
+		<p>Vedi la classe base [page:Object3D] per i metodi comuni.</p>
+
+		<h3>[method:Mesh clone]()</h3>
+		<p>Restituisce un clone di questo oggetto [name] e i suoi discendenti.</p>
+
+		<h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
+		<p>
+			Ottiene le intersezioni tra un raggio lanciato e questa mesh.
+			[page:Raycaster.intersectObject] chiamerà questo metodo, ma i risultati non saranno ordinati.
+		</p>
+
+		<h3>[method:undefined updateMorphTargets]()</h3>
+		<p>
+			Aggiorna i morphTargets in modo che non abbiano influenza sull'oggetto. Reimposta le proprietà
+			[page:Mesh.morphTargetInfluences morphTargetInfluences] e
+			[page:Mesh.morphTargetDictionary morphTargetDictionary].
+		</p>
+
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/objects/Points.html

@@ -0,0 +1,88 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Object3D] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una classe per visualizzare punti.
+			I punti sono renderizzati dal [page:WebGLRenderer] utilizzando
+			[link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.POINTS].
+		</p>
+
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3>
+		<p>
+			[page:BufferGeometry geometry] — (opzionale) un'istanza di [page:BufferGeometry]. Il valore predefinito è una nuova [page:BufferGeometry].<br />
+			[page:Material material] — (opzionale) un [page:Material Materiale]. Il valore predefinito è una nuova [page:PointsMaterial].
+		</p>
+
+		<h2>Proprietà</h2>
+		<p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p>
+
+		<h3>[property:BufferGeometry geometry]</h3>
+		<p>
+			Un'istanza di [page:BufferGeometry] (o classi derivate), che definisce la struttura dell'oggetto.
+		</p>
+
+		<h3>[property:Boolean isPoints]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h3>[property:Material material]</h3>
+		<p>
+			Un'istanza di [page:Material], che definisce
+			l'aspetto dell'oggetto. Il valore predefinito è [page:PointsMaterial].
+		</p>
+
+		<h3>[property:Array morphTargetInfluences]</h3>
+		<p>
+			Un array di pesi solitamente da 0 a 1 che specifica la quantità di morph applicata.
+			Non definito per impostazione predefinita, ma reimpostato su un array vuoto da [page:Points.updateMorphTargets updateMorphTargets].
+		</p>
+
+		<h3>[property:Object morphTargetDictionary]</h3>
+		<p>
+			Un dizionario di morphTargets basato sulla proprietà morphTarget.name.
+			Non definito per impostazione predefinita, ma ricompilato [page:Points.updateMorphTargets updateMorphTargets].
+		</p>
+
+		<h2>Metodi</h2>
+		<p>Vedi la classe base [page:Object3D] per i metodi comuni.</p>
+
+		<h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
+		<p>
+			Ottiene le intersezioni tra un raggio lanciato e questo Points.
+			[page:Raycaster.intersectObject] chiamerà questo metodo, ma i risultati non saranno ordinati.
+		</p>
+
+		<h3>[method:Points clone]()</h3>
+		<p>
+			Restituisce un clone di questo oggetto [name] e i suoi discendenti.</p>
+		</p>
+
+		<h3>[method:undefined updateMorphTargets]()</h3>
+		<p>
+			Aggiorna i morphTargets in modo che non abbiano influenza sull'oggetto. Reimposta le proprietà
+			[page:Points.morphTargetInfluences morphTargetInfluences] e
+			[page:Points.morphTargetDictionary morphTargetDictionary].
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+
+	</body>
+</html>

docs/api/it/objects/Skeleton.html

@@ -0,0 +1,129 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Utilizza un array di [page:Bone ossa] per creare uno scheletro che può essere utilizzato da una
+			[page:SkinnedMesh].
+		</p>
+
+		<h2>Codice di Esempio</h2>
+		<code>
+		// Crea un semplice "braccio"
+
+		const bones = [];
+
+		const shoulder = new THREE.Bone();
+		const elbow = new THREE.Bone();
+		const hand = new THREE.Bone();
+
+		shoulder.add( elbow );
+		elbow.add( hand );
+
+		bones.push( shoulder );
+		bones.push( elbow );
+		bones.push( hand );
+
+		shoulder.position.y = -5;
+		elbow.position.y = 0;
+		hand.position.y = 5;
+
+		const armSkeleton = new THREE.Skeleton( bones );
+		</code>
+
+		<p>
+			Vedi la pagina [page:SkinnedMesh] per un esempio dell'utilizzo con [page:BufferGeometry].
+ 		</p>
+
+		<h2>Costruttore</h2>
+
+
+		<h3>[name]( [param:Array bones], [param:Array boneInverses] )</h3>
+		<p>
+		[page:Array bones] - L'array di [page:Bone ossa]. Il valore predefinito è un array vuoto.<br/>
+		[page:Array boneInverses] - (opzionale) Un array di [page:Matrix4 Matrix4].<br /><br />
+
+		Crea un nuovo [name].
+		</p>
+
+
+		<h2>Proprietà</h2>
+
+		<h3>[property:Array bones]</h3>
+		<p>
+			L'array di [page:Bone ossa]. Si noti che questa è una copia dell'array originale, non un riferimento,
+			quindi puoi modificare l'array originale senza che ci siano effetti su questo.
+		</p>
+
+		<h3>[property:Array boneInverses]</h3>
+		<p>
+			Un array di [page:Matrix4 Matrix4] che rappresenta l'inverso della [page:Matrix4 matrixWorld]
+			delle singole ossa.
+		</p>
+
+		<h3>[property:Float32Array boneMatrices]</h3>
+		<p>
+			Il buffer dell'array che contiene i dati dell'osso quando si utilizza una texture di vertice.
+		</p>
+
+		<h3>[property:DataTexture boneTexture]</h3>
+		<p>
+			Il [page:DataTexture] che contiene i dati dell'osso quando si utilizza una texture di vertice.
+		</p>
+
+		<h3>[property:Integer boneTextureSize]</h3>
+		<p>
+			La dimensione del [page:.boneTexture].
+		</p>
+
+		<h2>Metodi</h2>
+
+		<h3>[method:Skeleton clone]()</h3>
+		<p>
+			Restituisce un clone di questo oggetto Skeleton.
+		</p>
+
+		<h3>[method:undefined calculateInverses]()</h3>
+		<p>Genera l'array [page:.boneInverses boneInverses] se non viene fornito nel costruttore.</p>
+
+		<h3>[method:this computeBoneTexture]()</h3>
+		<p>Calcola un'istanza di [page:DataTexture] in moda da passare i dati dell'osso in modo più efficiente allo shader.
+			La texture viene assegnata a [page:.boneTexture boneTexture].</p>
+
+		<h3>[method:undefined pose]()</h3>
+		<p>Restituisce lo scheletro nella posa di base.</p>
+
+		<h3>[method:undefined update]()</h3>
+		<p>
+			Aggiorna [page:Float32Array boneMatrices] e [page:DataTexture boneTexture] dopo che le ossa sono state modificate.
+			Questo viene chiamato automaticamente dal [page:WebGLRenderer] se lo scheletro viene utilizzato con una [page:SkinnedMesh].
+		</p>
+
+		<h3>[method:Bone getBoneByName]( [param:String name] )</h3>
+		<p>
+		name -- Stringa da abbinare alla proprietà .name di Bone. <br /><br />
+
+		Cerca nell'array osseo dello scheletro e restituisce il primo con un nome corrispondente.<br />
+		</p>
+
+		<h3>[method:undefined dispose]()</h3>
+		<p>
+			Libera le risorse relative alla GPU allocate da questa istanza. Chiama questo metodo ogni 
+			volta che questa istanza non viene più utilizzata nella tua app.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/objects/SkinnedMesh.html

@@ -0,0 +1,174 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Object3D] &rarr; [page:Mesh] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una mesh che ha uno [page:Skeleton scheletro] con [page:Bone ossa] che può essere 
+			utilizzata per animare i vertici della geometria.<br /><br />
+
+			[name] può essere utilizzata solo con WebGL 2. Con WebGL 1 è necessario il supporto delle texture del vertice
+			e `OES_texture_float`.
+		</p>
+
+		<iframe id="scene" src="scenes/bones-browser.html"></iframe>
+
+		<script>
+
+		// iOS iframe auto-resize workaround
+
+		if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
+
+			const scene = document.getElementById( 'scene' );
+
+			scene.style.width = getComputedStyle( scene ).width;
+			scene.style.height = getComputedStyle( scene ).height;
+			scene.setAttribute( 'scrolling', 'no' );
+
+		}
+
+		</script>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const geometry = new THREE.CylinderGeometry( 5, 5, 5, 5, 15, 5, 30 );
+
+		// crea manualmente gli indici della pelle e i pesi della pelle
+		// (tipicamente un loader leggerebbe questi dati da un modello 3D per te)
+
+		const position = geometry.attributes.position;
+
+		const vertex = new THREE.Vector3();
+
+		const skinIndices = [];
+		const skinWeights = [];
+
+		for ( let i = 0; i < position.count; i ++ ) {
+
+			vertex.fromBufferAttribute( position, i );
+
+			// calcola skinIndex e skinWeight in base ad alcuni dati di configurazione
+
+			const y = ( vertex.y + sizing.halfHeight );
+
+			const skinIndex = Math.floor( y / sizing.segmentHeight );
+			const skinWeight = ( y % sizing.segmentHeight ) / sizing.segmentHeight;
+
+			skinIndices.push( skinIndex, skinIndex + 1, 0, 0 );
+			skinWeights.push( 1 - skinWeight, skinWeight, 0, 0 );
+
+		}
+
+		geometry.setAttribute( 'skinIndex', new THREE.Uint16BufferAttribute( skinIndices, 4 ) );
+		geometry.setAttribute( 'skinWeight', new THREE.Float32BufferAttribute( skinWeights, 4 ) );
+
+		// crea skinned mesh e skeleton
+
+		const mesh = new THREE.SkinnedMesh( geometry, material );
+		const skeleton = new THREE.Skeleton( bones );
+
+		// vedi esempio da THREE.Skeleton
+
+		const rootBone = skeleton.bones[ 0 ];
+		mesh.add( rootBone );
+
+		// lega lo scheletro alla mesh
+
+		mesh.bind( skeleton );
+
+		// muove le ossa e manipola il modello
+
+		skeleton.bones[ 0 ].rotation.x = -0.1;
+		skeleton.bones[ 1 ].rotation.x = 0.2;
+		</code>
+
+		<h2>Costruttore</h2>
+		<h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3>
+		<p>
+		[page:BufferGeometry geometry] - un'istanza di [page:BufferGeometry].<br />
+		[page:Material material] - (opzionale) un'istanza di [page:Material]. Il valore predefinito è un nuovo [page:MeshBasicMaterial].
+		</p>
+
+		<h2>Proprietà</h2>
+		<p>Vedi la classe base [page:Mesh] per le proprietà comuni.</p>
+
+		<h3>[property:String bindMode]</h3>
+		<p>
+			O "attached" o "detached". "attached" utilizza la proprietà [page:SkinnedMesh.matrixWorld]
+			per la matrice di trasformazione delle ossa. "detached" utilizza [page:SkinnedMesh.bindMatrix]. Il valore predefinito è "attached".
+		</p>
+
+		<h3>[property:Matrix4 bindMatrix]</h3>
+		<p>
+			La matrice di base che viene utilizzata per le trasformazioni ossee vincolate.
+		</p>
+
+		<h3>[property:Matrix4 bindMatrixInverse]</h3>
+		<p>
+			La matrice di base che viene utilizzata per reimpostare le trasformazioni ossee vincolate.
+		</p>
+
+		<h3>[property:Boolean isSkinnedMesh]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+		<h3>[property:Skeleton skeleton]</h3>
+		<p>
+			[page:Skeleton] che rappresenta la gerarchia ossea della skinned mesh.
+		</p>
+
+		<h2>Metodi</h2>
+		<p>Vedi la classe base [page:Mesh] per i metodi comuni.</p>
+
+		<h3>[method:undefined bind]( [param:Skeleton skeleton], [param:Matrix4 bindMatrix] )</h3>
+		<p>
+		[page:Skeleton skeleton] - [page:Skeleton] creato da un albero di [page:Bone Bones].<br/>
+		[page:Matrix4 bindMatrix] - [page:Matrix4] che rappresenta la trasformazione base dello scheletro.<br /><br />
+
+		Lega uno scheletro alla skinned mesh. Il bindMatrix viene salvato nella proprietà .bindMatrix
+		e il .bindMatrixInverse viene calcolato.
+		</p>
+
+		<h3>[method:SkinnedMesh clone]()</h3>
+		<p>
+			Questo metodo attualmente non clona correttamente un'istanza di [name]. Si prega di utilizzare [page:SkeletonUtils.clone]() nel frattempo.
+		</p>
+
+		<h3>[method:undefined normalizeSkinWeights]()</h3>
+		<p>
+			Normalizza i pesi della skin.
+		</p>
+
+		<h3>[method:undefined pose]()</h3>
+		<p>
+			Questo metodo imposta la skinned mesh nella posa di riposo (reimposta la posa).
+		</p>
+
+		<h3>[method:Vector3 boneTransform]( [param:Integer index], [param:Vector3 target] )</h3>
+		<p>
+			Calcola la posizione del vertice in corrispondenza dell'indice specificato rispetto alle attuali trasformazioni ossee.
+			Il vettore target deve essere inizializzato con le coordinate del vertice prima della trasformazione:
+		<code>
+const target = new THREE.Vector3();
+target.fromBufferAttribute( mesh.geometry.attributes.position, index );
+mesh.boneTransform( index, target );
+		</code>
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/it/objects/Sprite.html

@@ -0,0 +1,89 @@
+<!DOCTYPE html>
+<html lang="it">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:Object3D] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+			Una sprite è un piano che è sempre rivolto verso la telecamera, generalmente con
+			una texture parzialmente trasparente applicata.<br /><br />
+
+			Le sprite non proiettano ombre, impostare <code>castShadow = true</code> non avrà alcun effetto. 
+		</p>
+
+		<h2>Codice di Esempio</h2>
+
+		<code>
+		const map = new THREE.TextureLoader().load( 'sprite.png' );
+		const material = new THREE.SpriteMaterial( { map: map } );
+
+		const sprite = new THREE.Sprite( material );
+		scene.add( sprite );
+		</code>
+
+		<h2>Costruttore</h2>
+
+		<h3>[name]( [param:Material material] )</h3>
+		<p>
+    [page:Material material] - (opzionale) un'istanza di [page:SpriteMaterial]. Il valore predefinito è una [page:SpriteMaterial] bianca.<br /><br />
+
+		Crea una nuova [name].
+		</p>
+
+		<h2>Proprietà</h2>
+		<p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p>
+
+		<h3>[property:Boolean isSprite]</h3>
+		<p>
+			Flag di sola lettura per verificare se l'oggetto dato è di tipo [name].
+		</p>
+
+
+		<h3>[property:SpriteMaterial material]</h3>
+		<p>
+			Un'istanza di [page:SpriteMaterial], che definisce l'aspetto dell'oggetto.
+			Il valore predefinito è una [page:SpriteMaterial] bianca.
+		</p>
+
+
+		<h3>[property:Vector2 center]</h3>
+		<p>
+			Il punto di ancoraggio della sprite, e il punto attorno al quale ruota la sprite. Un valore di (0.5, 0.5) 
+			corrisponde al punto medio della sprite. Un valore di (0, 0) corrisponde all'angolo inferiore sinistro della sprite.
+			Il valore predefinito è (0.5, 0.5).
+		</p>
+
+		<h2>Metodi</h2>
+		<p>Vedi la classe base [page:Object3D] per i metodi comuni.</p>
+
+		<h3>[method:Sprite clone]()</h3>
+		<p>
+			Restituisce un clone di questo oggetto Sprite e i suoi discendenti.
+		</p>
+
+		<h3>[method:this copy]( [param:Sprite sprite] )</h3>
+		<p>
+			Copia le proprietà della sprite passata in questa.
+		</p>
+
+		<h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
+		<p>
+			Ottiene le intersezioni tra un raggio lanciato e questa sprite. [page:Raycaster.intersectObject]() chiamerà questo metodo.
+			Il raycaster deve essere inizializzato chiamando [page:Raycaster.setFromCamera]() prima di eseguire il raycast contro le sprite.
+		</p>
+
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/ko/core/Object3D.html

@@ -313,7 +313,7 @@
 		이 메서드는 비균일 스케일 부모를 가진 객체들은 지원하지 않습니다.
 		</p>
 
-		<h3>[method:Array raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
+		<h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
 		<p>
 		객체와 레이캐스팅 사이의 인터섹션을 구하는 추상 (빈) 메서드입니다.
 		Subclasses such as [page:Mesh], [page:Line], 및 [page:Points] 같은 서브클래스들은 레이캐스팅을 사용하는 순서에 따라 이 메서드를 실행합니다.

docs/api/zh/core/Object3D.html

@@ -304,7 +304,7 @@
 		这一方法不支持其父级被旋转过或者被位移过的物体。
 	</p>
 
-	<h3>[method:Array raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
+	<h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
 	<p>抽象（空方法），在一条被投射出的射线与这个物体之间获得交点。
 		在一些子类，例如[page:Mesh], [page:Line], and [page:Points]实现了这个方法，以用于光线投射。
 	</p>

docs/api/zh/materials/MeshLambertMaterial.html

@@ -13,7 +13,7 @@
 
 		<p class="desc"> 一种非光泽表面的材质，没有镜面高光。<br /><br />
 			该材质使用基于非物理的[link:https://en.wikipedia.org/wiki/Lambertian_reflectance Lambertian]模型来计算反射率。
-			这可以很好地模拟一些表面（例如未经处理的木材或石材），但不能模拟具有镜面高光的光泽表面（例如涂漆木材）。 [name] uses per-fragmet shading。<br /><br />
+			这可以很好地模拟一些表面（例如未经处理的木材或石材），但不能模拟具有镜面高光的光泽表面（例如涂漆木材）。 [name] uses per-fragment shading。<br /><br />
 
 			由于反射率和光照模型的简单性，[page:MeshPhongMaterial]，[page:MeshStandardMaterial]或者[page:MeshPhysicalMaterial]
 			上使用这种材质时会以一些图形精度为代价，得到更高的性能。

docs/api/zh/materials/MeshPhongMaterial.html

@@ -13,7 +13,7 @@
 
 		<p class="desc"> 一种用于具有镜面高光的光泽表面的材质。<br /><br />
 			该材质使用非物理的[link:https://en.wikipedia.org/wiki/Blinn-Phong_shading_model Blinn-Phong]模型来计算反射率。
-			与[page:MeshLambertMaterial]中使用的Lambertian模型不同，该材质可以模拟具有镜面高光的光泽表面（例如涂漆木材）。[name] uses per-fragmet shading。<br /><br />
+			与[page:MeshLambertMaterial]中使用的Lambertian模型不同，该材质可以模拟具有镜面高光的光泽表面（例如涂漆木材）。[name] uses per-fragment shading。<br /><br />
 
 			在[page:MeshStandardMaterial]或[page:MeshPhysicalMaterial]上使用此材质时，性能通常会更高	，但会牺牲一些图形精度。
 		</p>

docs/api/zh/materials/MeshPhysicalMaterial.html

@@ -25,6 +25,9 @@
 			<li>
 				<b>高级光线反射:</b> 为非金属材质提供了更多更灵活的光线反射。
 			</li>
+			<li>
+				<b>Sheen:</b> Can be used for representing cloth and fabric materials.
+			</li>
 		</ul>
 
 		<p>
@@ -55,6 +58,7 @@
 			[example:webgl_materials_variations_physical materials / variations / physical]<br />
 			[example:webgl_materials_physical_clearcoat materials / physical / clearcoat]<br />
 			[example:webgl_materials_physical_reflectivity materials / physical / reflectivity]<br />
+			[example:webgl_loader_gltf_sheen loader / gltf / sheen]<br />
 			[example:webgl_materials_physical_transmission materials / physical / transmission]
 		</p>
 

docs/api/zh/materials/MeshStandardMaterial.html

@@ -18,7 +18,7 @@
 			这种方法与旧方法的不同之处在于，不使用近似值来表示光与表面的相互作用，而是使用物理上正确的模型。
 			我们的想法是，不是在特定照明下调整材质以使其看起来很好，而是可以创建一种材质，能够“正确”地应对所有光照场景。<br /><br />
 
-			在实践中，该材质提供了比[page:MeshLambertMaterial] 或[page:MeshPhongMaterial] 更精确和逼真的结果，代价是计算成本更高。[name] uses per-fragmet shading。<br /><br />
+			在实践中，该材质提供了比[page:MeshLambertMaterial] 或[page:MeshPhongMaterial] 更精确和逼真的结果，代价是计算成本更高。[name] uses per-fragment shading。<br /><br />
 
 			请注意，为获得最佳效果，您在使用此材质时应始终指定[page:.envMap environment map]。<br /><br />
 			有关PBR概念的非技术性介绍以及如何设置PBR材质，请查看[link:https://www.marmoset.co marmoset]成员的这些文章：

docs/api/zh/math/Euler.html

@@ -145,14 +145,6 @@
 		返回一个数组：[[page:.x x], [page:.y y], [page:.z z], [page:.order order ]]。
 		</p>
 
-		<h3>[method:Vector3 toVector3]( [param:Vector3 optionalResult] )</h3>
-		<p>
-			[page:Vector3 optionalResult] — (可选参数) 如果指定了该参数结果将会被复制给该参数，否者会创建一个新的 Vector3 <br /><br />
-
-			以 [page:Vector3] 的形式返回欧拉角的 [page:.x x], [page:.y y] 和 [page:.z z]。
-		</p>
-
-
 		<h2>源码（Source）</h2>
 
 		<p>

docs/api/zh/math/Vector3.html

@@ -358,6 +358,11 @@
 		<h3>[method:this setFromCylindricalCoords]( [param:Float radius], [param:Float theta], [param:Float y] )</h3>
 		<p>从圆柱坐标中的[page:Cylindrical radius]、[page:Cylindrical theta]和[page:Cylindrical y]设置该向量。</p>
 
+		<h3>[method:this setFromEuler]( [param:Euler euler] )</h3>
+		<p>
+		根据指定的[page:Euler Euler Angle]的x、y、z分量来设置该向量的[page:.x x]、[page:.y y]、[page:.z z]分量。
+		</p>
+		
 		<h3>[method:this setFromMatrixColumn]( [param:Matrix4 matrix], [param:Integer index] )</h3>
 		<p>
 		从传入的四阶矩阵[page:Matrix4 matrix]由[page:Integer index]指定的列中，

docs/api/zh/objects/LOD.html

@@ -99,7 +99,7 @@
 			获得第一个比[page:Float distance]大的[page:Object3D]（网格）的引用。
 		</p>
 
-		<h3>[method:Array raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
+		<h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3>
 		<p>
 			在一条投射出去的[page:Ray]（射线）和这个LOD之间获得交互。
 			[page:Raycaster.intersectObject]将会调用这个方法。

docs/api/zh/renderers/WebGLCubeRenderTarget.html

@@ -25,7 +25,7 @@
 
 		<h3>[name]([param:Number size], [param:Object options])</h3>
 		<p>
-		[page:Float size] - the size, in pixels. <br />
+		[page:Float size] - the size, in pixels. Default is `1`.<br />
 		options - (可选)一个保存着自动生成的目标纹理的纹理参数以及表示是否使用深度缓存/模板缓存的布尔值的对象。
 		有关纹理参数的说明，请参阅[page:Texture Texture]. 以下是合理选项：<br /><br />
 

docs/api/zh/renderers/WebGLMultipleRenderTargets.html

@@ -30,9 +30,9 @@
 		<h3>[name]([param:Number width], [param:Number height], [param:Number count])</h3>
 
 		<p>
-		[page:Number width] - The width of the render target. <br />
-		[page:Number height] - The height of the render target.<br />
-		[page:Number count] - The number of render targets.
+		[page:Number width] - The width of the render target. Default is `1`.<br />
+		[page:Number height] - The height of the render target. Default is `1`.<br />
+		[page:Number count] - The number of render targets. Default is `1`.
 		</p>
 
 		<h2>Properties</h2>

docs/api/zh/renderers/WebGLRenderTarget.html

@@ -22,8 +22,8 @@
 		<h3>[name]([param:Number width], [param:Number height], [param:Object options])</h3>
 
 		<p>
-		[page:Float width] -renderTarget的宽度 <br />
-		[page:Float height] - renderTarget的高度 <br />
+		[page:Float width] -renderTarget的宽度. Default is `1`.<br />
+		[page:Float height] - renderTarget的高度. Default is `1`.<br />
 		options - (可选)一个保存着自动生成的目标纹理的纹理参数以及表示是否使用深度缓存/模板缓存的布尔值的对象
 		以下是一些合法选项：<br /><br />
 
@@ -31,13 +31,14 @@
 		[page:Constant wrapT] - 默认是[page:Textures ClampToEdgeWrapping]. <br />
 		[page:Constant magFilter] - 默认是[page:Textures LinearFilter]. <br />
 		[page:Constant minFilter] - 默认是[page:Textures LinearFilter]. <br />
-		[page:Boolean generateMipmaps] - 默认是*false*.<br />
+		[page:Boolean generateMipmaps] - 默认是`false`.<br />
 		[page:Constant format] - 默认是[page:Textures RGBAFormat]. <br />
 		[page:Constant type] - 默认是[page:Textures UnsignedByteType]. <br />
-		[page:Number anisotropy] - 默认是*1*. 参见[page:Texture.anisotropy]<br />
+		[page:Number anisotropy] - 默认是`1`. 参见[page:Texture.anisotropy]<br />
 		[page:Constant encoding] - 默认是[page:Textures LinearEncoding]. <br />
-		[page:Boolean depthBuffer] - 默认是*true*.<br />
-		[page:Boolean stencilBuffer] - 默认是*false*.<br /><br />
+		[page:Boolean depthBuffer] - 默认是`true`.<br />
+		[page:Boolean stencilBuffer] - 默认是`false`.<br />
+		[page:Number samples] - 默认是`0`.<br /><br />
 
 		创建一个新[name]
 		</p>

docs/api/zh/renderers/WebGLRenderer.html

@@ -335,7 +335,7 @@
 
 		<h3>[method:undefined readRenderTargetPixels]( [param:WebGLRenderTarget renderTarget], [param:Float x], [param:Float y], [param:Float width], [param:Float height], [param:TypedArray buffer], [param:Integer activeCubeFaceIndex] )</h3>
 		<p>buffer - Uint8Array is the only destination type supported in all cases, other types are renderTarget and platform dependent. See [link:https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.12 WebGL spec] for details.</p>
-		<p>将enderTarget中的像素数据读取到传入的缓冲区中。这是[link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/readPixels WebGLRenderingContext.readPixels]()的包装器<br />
+		<p>将renderTarget中的像素数据读取到传入的缓冲区中。这是[link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/readPixels WebGLRenderingContext.readPixels]()的包装器<br />
 		示例：[example:webgl_interactive_cubes_gpu interactive / cubes / gpu]</p>
 		<p>For reading out a [page:WebGLCubeRenderTarget WebGLCubeRenderTarget] use the optional parameter activeCubeFaceIndex to determine which face should be read.</p>
 

docs/api/zh/scenes/Scene.html

@@ -32,6 +32,11 @@
 		或是 a cubemap as a [page:CubeTexture] or an equirectangular as a [page:Texture]。默认值为null。
 		</p>
 
+		<h3>[property:Float backgroundBlurriness]</h3>
+		<p>
+			Sets the blurriness of the background. Only influences environment maps assigned to [page:Scene.background]. Valid input is a float between *0* and *1*. Default is *0*.
+		</p>
+
 		<h3>[property:Texture environment]</h3>
 		<p>
     若该值不为null，则该纹理贴图将会被设为场景中所有物理材质的环境贴图。

docs/api/zh/textures/CompressedArrayTexture.html

@@ -0,0 +1,75 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<base href="../../../" />
+		<script src="page.js"></script>
+		<link type="text/css" rel="stylesheet" href="page.css" />
+	</head>
+	<body>
+		[page:CompressedTexture] &rarr;
+
+		<h1>[name]</h1>
+
+		<p class="desc">
+		Creates an texture 2D array based on data in compressed form, for example from a [link:https://en.wikipedia.org/wiki/DirectDraw_Surface DDS] file.<br /><br />
+
+
+		For use with the [page:CompressedTextureLoader CompressedTextureLoader].
+		</p>
+
+
+		<h2>Constructor</h2>
+
+
+		<h3>[name]( [param:Array mipmaps], [param:Number width], [param:Number height], [param:Constant format], [param:Constant type] )</h3>
+		<p>
+		[page:Array mipmaps] -- The mipmaps array should contain objects with data, width and height. The mipmaps should be of the correct format and type.<br />
+
+		[page:Number width] -- The width of the biggest mipmap.<br />
+
+		[page:Number height] -- The height of the biggest mipmap.<br />
+
+		[page:Number depth] -- The number of layers of the 2D array texture.<br />
+
+		[page:Constant format] -- The format used in the mipmaps.
+		See [page:Textures ST3C Compressed Texture Formats],
+		[page:Textures PVRTC Compressed Texture Formats] and
+		[page:Textures ETC Compressed Texture Format] for other choices.<br />
+
+		[page:Constant type] -- Default is [page:Textures THREE.UnsignedByteType].
+		See [page:Textures type constants] for other choices.<br />
+
+		</p>
+
+
+		<h2>Properties</h2>
+
+		See the base [page:CompressedTexture CompressedTexture] class for common properties.
+
+		<h3>[property:number wrapR]</h3>
+		<p>
+		This defines how the texture is wrapped in the depth direction.<br />
+		The default is [page:Textures THREE.ClampToEdgeWrapping], where the edge is clamped to the outer edge texels.
+		The other two choices are [page:Textures THREE.RepeatWrapping] and [page:Textures THREE.MirroredRepeatWrapping].
+		See the [page:Textures texture constants] page for details.
+		</p>
+
+		<h3>[property:Boolean isCompressedArrayTexture]</h3>
+		<p>
+			Read-only flag to check if a given object is of type [name].
+		</p>
+
+		<h2>Methods</h2>
+
+		<p>
+		See the base [page:CompressedTexture CompressedTexture] class for common methods.
+		</p>
+
+		<h2>Source</h2>
+
+		<p>
+			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
+		</p>
+	</body>
+</html>

docs/api/zh/textures/VideoTexture.html

@@ -12,9 +12,11 @@
 		<h1>视频纹理（[name]）</h1>
 
 		<p class="desc">
-		创建一个使用视频来作为贴图的纹理对象。<br /><br />
+		创建一个使用视频来作为贴图的纹理对象。
+		</p>
 
-		它和其基类[page:Texture Texture]几乎是相同的，除了它总是将[page:Texture.needsUpdate needsUpdate]设置为*true*，以便使得贴图能够在视频播放时进行更新。自动创建[page:Texture.mipmaps mipmaps]也会被禁用。
+		<p>
+			Note: After the initial use of a texture, the video cannot be changed. Instead, call [page:.dispose]() on the texture and instantiate a new one.
 		</p>
 
 		<h2>代码示例</h2>
@@ -27,7 +29,13 @@ const texture = new THREE.VideoTexture( video );
 
 		<h2>例子</h2>
 
-		<p>[example:webgl_materials_video materials / video ]</p>
+		<p>
+			[example:webgl_materials_video materials / video]<br />
+			[example:webgl_materials_video_webcam materials / video / webcam]<br />
+			[example:webgl_video_kinect video / kinect]<br />
+			[example:webgl_video_panorama_equirectangular video / panorama / equirectangular]<br />
+			[example:webxr_vr_video vr / video]
+		</p>
 
 		<h2>构造函数</h2>
 		<h3>[name]( [param:Video video], [param:Constant mapping], [param:Constant wrapS], [param:Constant wrapT], [param:Constant magFilter], [param:Constant minFilter], [param:Constant format], [param:Constant type], [param:Number anisotropy] )</h3>
@@ -47,7 +55,7 @@ const texture = new THREE.VideoTexture( video );
 		其默认值为[page:Textures THREE.LinearFilter]。请参阅[page:Textures magnification filter constants]（放大滤镜常量）来了解其它选项。<br />
 
 		[page:Constant minFilter] -- 当一个纹素覆盖小于一个像素时，贴图将如何采样。
-		其默认值为[page:Textures THREE.LinearMipmapLinearFilter]。请参阅[page:Textures minification filter constants]（缩小滤镜常量）来了解其它选项。<br />
+		其默认值为[page:Textures THREE.LinearFilter]。请参阅[page:Textures minification filter constants]（缩小滤镜常量）来了解其它选项。<br />
 
 		[page:Constant format] -- The default is [page:Textures THREE.RGBAFormat].
 	 	请参阅[page:Textures format constants]（格式常量）来了解各个选项。<br />
@@ -69,7 +77,7 @@ const texture = new THREE.VideoTexture( video );
 
 		<h3>[property:Boolean generateMipmaps]</h3>
 		<p>
-		Whether to generate mipmaps. False by default.
+		Whether to generate mipmaps. `false` by default.
 		</p>
 
 		<h3>[property:Boolean isVideoTexture]</h3>
@@ -79,7 +87,7 @@ const texture = new THREE.VideoTexture( video );
 
 		<h3>[property:Boolean needsUpdate]</h3>
 		<p>
-		在这里，你不必手动设置这个值，因为它是由[page:VideoTexture.update update]方法来进行控制的。
+		在这里，你不必手动设置这个值，因为它是由[page:VideoTexture.update update]()方法来进行控制的。
 		</p>
 
 		<h2>方法</h2>