+THREE.LoopOnce
+THREE.LoopRepeat
+THREE.LoopPingPong
+
+
+
+THREE.InterpolateDiscrete
+THREE.InterpolateLinear
+THREE.InterpolateSmooth
+
+
+
+THREE.ZeroCurvatureEnding
+THREE.ZeroSlopeEnding
+THREE.WrapAroundEnding
+
+
+
+THREE.NormalAnimationBlendMode
+THREE.AdditiveAnimationBlendMode
+
+
+ + [link:https://github.com/mrdoob/three.js/blob/master/src/constants.js src/constants.js] +
+ + diff --git a/docs/api/fr/constants/BufferAttributeUsage.html b/docs/api/fr/constants/BufferAttributeUsage.html new file mode 100644 index 00000000000000..d5e36bbb745699 --- /dev/null +++ b/docs/api/fr/constants/BufferAttributeUsage.html @@ -0,0 +1,51 @@ + + + + ++ Les constantes d'utilisation peuvent être utilisées pour fournir une indication à l'API concernant la manière dont l'attribut de mémoire tampon (buffer attribute) de géométrie sera utilisé afin d'optimiser les performances. +
+ +
+ const geometry = new THREE.BufferGeometry();
+ const positionAttribute = new THREE.BufferAttribute( array, 3 , false );
+ positionAttribute.setUsage( THREE.DynamicDrawUsage );
+ geometry.setAttribute( 'position', positionAttribute );
+
+
+ [example:webgl_buffergeometry_drawrange materials / buffergeometry / drawrange ]
+ +
+ THREE.StaticDrawUsage
+ THREE.DynamicDrawUsage
+ THREE.StreamDrawUsage
+
+ THREE.StaticReadUsage
+ THREE.DynamicReadUsage
+ THREE.StreamReadUsage
+
+ THREE.StaticCopyUsage
+ THREE.DynamicCopyUsage
+ THREE.StreamCopyUsage
+
+
+ Pour plus d'informations sur chacune de ces constantes, voir [link:https://www.khronos.org/opengl/wiki/Buffer_Object#Buffer_Object_Usage this OpenGL documentation].
+
+ + [link:https://github.com/mrdoob/three.js/blob/master/src/constants.js src/constants.js] +
+ + diff --git a/docs/api/fr/constants/Core.html b/docs/api/fr/constants/Core.html new file mode 100644 index 00000000000000..1f6bc2203bc63a --- /dev/null +++ b/docs/api/fr/constants/Core.html @@ -0,0 +1,80 @@ + + + + +
+THREE.REVISION
+
+
+
+THREE.NoColorSpace
+THREE.SRGBColorSpace
+THREE.LinearSRGBColorSpace
+
+ + [page:NoColorSpace] ne définit aucun espace colorimétrique spécifique. +
++ [page:SRGBColorSpace] (“sRGB”) fait référence à l'espace colorimétrique défini par la Rec. 709 primaires, D65 + point blanc et fonctions de transfert sRGB non linéaires. sRGB est l'espace colorimétrique par défaut dans + CSS, et se trouve souvent dans les palettes de couleurs et les sélecteurs de couleurs. Les couleurs exprimées en + notation hexadécimale ou en CSS sont généralement dans l'espace colorimétrique sRGB. +
+ ++ [page:LinearSRGBColorSpace] (“Linear-sRGB”) fait référence à l'espace colorimétrique sRGB (ci-dessus) avec + fonctions de transfert linéaires. Linear-sRGB est l'espace colorimétrique de travail dans three.js, utilisé + pendant la majeure partie du processus de rendu. Les composants RVB trouvés dans les matériaux three.js + et dans les shaders sont dans l'espace colorimétrique Linear-sRGB. +
+ ++ Pour plus d'informations d'utilisation, voir Color management. +
+ +
+THREE.MOUSE.LEFT
+THREE.MOUSE.MIDDLE
+THREE.MOUSE.RIGHT
+THREE.MOUSE.ROTATE
+THREE.MOUSE.DOLLY
+THREE.MOUSE.PAN
+
+ + Les constantes LEFT et ROTATE ont la même valeur sous-jacente. + Les constantes MIDDLE et DOLLY ont la même valeur sous-jacente. + Les constantes RIGHT et PAN ont la même valeur sous-jacente. +
+ +
+THREE.TOUCH.ROTATE
+THREE.TOUCH.PAN
+THREE.TOUCH.DOLLY_PAN
+THREE.TOUCH.DOLLY_ROTATE
+
+
+ + [link:https://github.com/mrdoob/three.js/blob/master/src/constants.js src/constants.js] +
+ + + + diff --git a/docs/api/fr/constants/CustomBlendingEquations.html b/docs/api/fr/constants/CustomBlendingEquations.html new file mode 100644 index 00000000000000..d3267a0c24b516 --- /dev/null +++ b/docs/api/fr/constants/CustomBlendingEquations.html @@ -0,0 +1,64 @@ + + + + ++ Elles fonctionnent avec tous les types de matériaux. Définissez d'abord le mode de fusion du matériau sur THREE.CustomBlending, définissez ensuite l'équation de fusion, le facteur source et le facteur de destination souhaités. +
+ +
+ const material = new THREE.MeshBasicMaterial( {color: 0x00ff00} );
+ material.blending = THREE.CustomBlending;
+ material.blendEquation = THREE.AddEquation; //default
+ material.blendSrc = THREE.SrcAlphaFactor; //default
+ material.blendDst = THREE.OneMinusSrcAlphaFactor; //default
+
+
+ [example:webgl_materials_blending_custom materials / blending / custom ]
+ +
+ THREE.AddEquation
+ THREE.SubtractEquation
+ THREE.ReverseSubtractEquation
+ THREE.MinEquation
+ THREE.MaxEquation
+
+
+
+ THREE.ZeroFactor
+ THREE.OneFactor
+ THREE.SrcColorFactor
+ THREE.OneMinusSrcColorFactor
+ THREE.SrcAlphaFactor
+ THREE.OneMinusSrcAlphaFactor
+ THREE.DstAlphaFactor
+ THREE.OneMinusDstAlphaFactor
+ THREE.DstColorFactor
+ THREE.OneMinusDstColorFactor
+ THREE.SrcAlphaSaturateFactor
+
+
+
+ Tous les facteurs source sont valides comme facteurs de destination, à l'exception de THREE.SrcAlphaSaturateFactor
+
+ [link:https://github.com/mrdoob/three.js/blob/master/src/constants.js src/constants.js] +
+ + diff --git a/docs/api/fr/constants/Materials.html b/docs/api/fr/constants/Materials.html new file mode 100644 index 00000000000000..bff834df896bea --- /dev/null +++ b/docs/api/fr/constants/Materials.html @@ -0,0 +1,153 @@ + + + + +
+ Ces constantes définissent des propriétés communes à tous les métériaux,
+ à l'exception de Texture Combine Operations qui s'applique uniquement à [page:MeshBasicMaterial.combine MeshBasicMaterial], [page:MeshLambertMaterial.combine MeshLambertMaterial] et [page:MeshPhongMaterial.combine MeshPhongMaterial].
+
+ THREE.FrontSide
+ THREE.BackSide
+ THREE.DoubleSide
+
+ + Définit quel côté des faces sera rendu - avant, arrière ou les deux. + La valeur par défaut est [page:Constant FrontSide]. +
+ +
+ THREE.NoBlending
+ THREE.NormalBlending
+ THREE.AdditiveBlending
+ THREE.SubtractiveBlending
+ THREE.MultiplyBlending
+ THREE.CustomBlending
+
+
+
+
+ Ces constantes contrôlent les équations de mélange source et destination pour le RVB et l'Alpha du matériau envoyés au WebGLRenderer pour être utilisés par WebGL.
+ [page:Constant NormalBlending] est la valeur par défaut.
+ Remarque : [page:Constant CustomBlending] doit être définit pour utiliser [page:CustomBlendingEquation Custom Blending Equations].
+ Voir l'exemple [example:webgl_materials_blending materials / blending].
+
+ THREE.NeverDepth
+ THREE.AlwaysDepth
+ THREE.EqualDepth
+ THREE.LessDepth
+ THREE.LessEqualDepth
+ THREE.GreaterEqualDepth
+ THREE.GreaterDepth
+ THREE.NotEqualDepth
+
+
+ Quelle fonction de profondeur le matériau utilise pour comparer la profondeur Z des pixels entrants à la valeur actuelle du tampon de profondeur Z. Si le résultat de la comparaison est `true`(vrai), le pixel sera dessiné.
+ [page:Materials NeverDepth] ne renvoie jamais `true`.
+ [page:Materials AlwaysDepth] renvoie toujours `true`.
+ [page:Materials EqualDepth] renvoie `true` si la profondeur Z du pixel entrant est égale à la profondeur Z du tampon actuel.
+ [page:Materials LessDepth] renvoie `true` si la profondeur Z du pixel entrant est inférieure à la profondeur Z du tampon actuel.
+ [page:Materials LessEqualDepth] si la profondeur Z du pixel entrant est inférieure ou égale à la profondeur Z du tampon actuel.
+ [page:Materials GreaterEqualDepth] renvoie `true` si la profondeur Z du pixel entrant est supérieure ou égale à la profondeur Z du tampon actuel.
+ [page:Materials GreaterDepth] renvoie `true` si la profondeur Z du pixel entrant est supérieure à la profondeur Z du tampon actuel.
+ [page:Materials NotEqualDepth] renvoie `true` si la profondeur Z du pixel entrant est différente de la profondeur Z du tampon actuel.
+
+ THREE.MultiplyOperation
+ THREE.MixOperation
+ THREE.AddOperation
+
+
+ Ces constantes définissent comment le résultat de la couleur de la surface est combiné avec la carte d'environnement (environnement map) (si présente), pour [page:MeshBasicMaterial.combine MeshBasicMaterial], [page:MeshLambertMaterial.combine MeshLambertMaterial] et [page:MeshPhongMaterial.combine MeshPhongMaterial].
+ [page:Constant MultiplyOperation] est la valeur par défaut qui multiplie la carte d'environnement et la couleur de la surface.
+ [page:Constant MixOperation] utilise la réflectivité pour mélanger les deux couleurs.
+ [page:Constant AddOperation] ajoute les deux couleurs.
+
+ THREE.NeverStencilFunc
+ THREE.LessStencilFunc
+ THREE.EqualStencilFunc
+ THREE.LessEqualStencilFunc
+ THREE.GreaterStencilFunc
+ THREE.NotEqualStencilFunc
+ THREE.GreaterEqualStencilFunc
+ THREE.AlwaysStencilFunc
+
+
+ Quelle fonction de gabarit le matériau utilise pour déterminer s'il faut ou non effectuer une opération de gabarit.
+ [page:Materials NeverStencilFunc] ne renvoie jamais `true`.
+ [page:Materials LessStencilFunc] renvoie `true` si la valeur de référence du gabarit est inférieure à la valeur courante du gabarit.
+ [page:Materials EqualStencilFunc] renvoie `true` si la valeur de référence du gabarit est égale à la valeur courante du gabarit.
+ [page:Materials LessEqualStencilFunc] renvoie `true` si la valeur de référence du gabarit est inférieure ou égale à la valeur courante du gabarit.
+ [page:Materials GreaterStencilFunc] renvoie `true` si la valeur de référence du gabarit est supérieure à la valeur courante du gabarit.
+ [page:Materials NotEqualStencilFunc] renvoie `true` si la valeur de référence du gabarit est différente de la valeur courante du gabarit.
+ [page:Materials GreaterEqualStencilFunc] renvoie `true` si la valeur de référence du gabarit est supérieure ou égale à la valeur courante du gabarit.
+ [page:Materials AlwaysStencilFunc] renvoie toujours `true`.
+
+ THREE.ZeroStencilOp
+ THREE.KeepStencilOp
+ THREE.ReplaceStencilOp
+ THREE.IncrementStencilOp
+ THREE.DecrementStencilOp
+ THREE.IncrementWrapStencilOp
+ THREE.DecrementWrapStencilOp
+ THREE.InvertStencilOp
+
+
+ Quelle opération de gabarit le matériau effectuera sur le pixel du tampon de gabarit si la fonction de gabarit fournie réussit.
+ [page:Materials ZeroStencilOp] définie la valeur du gabarit sur 0.
+ [page:Materials KeepStencilOp] ne change pas la valeur courante du gabarit.
+ [page:Materials ReplaceStencilOp] remplace la valeur du pochoir par la valeur de référence du pochoir spécifiée.
+ [page:Materials IncrementStencilOp] incrémente la valeur courante du gabarit de `1`.
+ [page:Materials DecrementStencilOp] décrémente la valeur courante du gabarit de `1`.
+ [page:Materials IncrementWrapStencilOp] incrémente la valeur courante du gabarit de `1`. Si la valeur incrémentée dépasse `255` elle sera définie à `0`.
+ [page:Materials DecrementWrapStencilOp] décrémente la valeur courante du gabarit de `1`. Si la valeur décrémentée dépasse `0` elle sera définie à `255`.
+ [page:Materials InvertStencilOp] Effectuera une inversion bit à bit de la valeur actuelle du pochoir.
+
+ THREE.TangentSpaceNormalMap
+ THREE.ObjectSpaceNormalMap
+
+ + Ces constantes définissent les types de carte normale. + Pour TangentSpaceNormalMap, l'information est relative à la surface sous-jacente. + For ObjectSpaceNormalMap, l'information est relative à la rotation de l'objet. + La valeur par défaut est [page:Constant TangentSpaceNormalMap]. +
+ +
+ THREE.GLSL1
+ THREE.GLSL3
+
+
+ + [link:https://github.com/mrdoob/three.js/blob/master/src/constants.js src/constants.js] +
+ + diff --git a/docs/api/fr/constants/Renderer.html b/docs/api/fr/constants/Renderer.html new file mode 100644 index 00000000000000..99e06448d9d0d1 --- /dev/null +++ b/docs/api/fr/constants/Renderer.html @@ -0,0 +1,69 @@ + + + + +
+ THREE.CullFaceNone
+ THREE.CullFaceBack
+ THREE.CullFaceFront
+ THREE.CullFaceFrontBack
+
+
+ [page:constant CullFaceNone] désactive l'élimination de face.
+ [page:constant CullFaceBack] élimine les faces arrières (par défaut).
+ [page:constant CullFaceFront] élimine les faces avant.
+ [page:constant CullFaceFrontBack] élimine les faces avant et arrière.
+
+ THREE.BasicShadowMap
+ THREE.PCFShadowMap
+ THREE.PCFSoftShadowMap
+ THREE.VSMShadowMap
+
+
+ Ces constantes définissent les propriétés [page:WebGLRenderer.shadowMap.type shadowMap.type] du moteur de rendu WebGL.
+
+ [page:constant BasicShadowMap] donne des textures d'ombres (shadow maps) non filtrées - plus rapide, mais de moins bonne qualité.
+ [page:constant PCFShadowMap] filtre les textures d'ombre à l'aide de l'algorithme PCF (percentage-closer filtering) (par défaut).
+ [page:constant PCFSoftShadowMap] filtre les textures d'ombre à l'aide de l'algorithme de filtrage en pourcentage plus proche (PCF) avec de meilleures ombres douces, en particulier lors de l'utilisation de cartes d'ombre à faible résolution.
+ [page:constant VSMShadowMap] filtre les textures d'ombres à l'aide de l'algorithme Variance Shadow Map (VSM). Lors de l'utilisation de VSMShadowMap, tous les récepteurs d'ombre projetteront également des ombres.
+
+ THREE.NoToneMapping
+ THREE.LinearToneMapping
+ THREE.ReinhardToneMapping
+ THREE.CineonToneMapping
+ THREE.ACESFilmicToneMapping
+ THREE.CustomToneMapping
+
+ + Ces constantes définissent les propriétés [page:WebGLRenderer.toneMapping toneMapping] du moteur de rendu webGL. + Elles sont utilisées pour se rapprocher de l'apparence de la plage dynamique élevée (HDR) sur le + milieu de plage dynamique faible d'un écran d'ordinateur standard ou d'un écran d'appareil mobile. +
++ THREE.LinearToneMapping, THREE.ReinhardToneMapping, THREE.CineonToneMapping et THREE.ACESFilmicToneMapping sont des implémentations intégrées à la cartographie des tons. + THREE.CustomToneMapping attend une implémentation personnalisée en modifiant le code GLSL du fragment shader du matériau. + Voir l'exemple [example:webgl_tonemapping WebGL / tonemapping]. +
+ + ++ [link:https://github.com/mrdoob/three.js/blob/master/src/constants.js src/constants.js] +
+ + diff --git a/docs/api/fr/constants/Textures.html b/docs/api/fr/constants/Textures.html new file mode 100644 index 00000000000000..8318f04598a352 --- /dev/null +++ b/docs/api/fr/constants/Textures.html @@ -0,0 +1,560 @@ + + + + +
+ THREE.UVMapping
+ THREE.CubeReflectionMapping
+ THREE.CubeRefractionMapping
+ THREE.EquirectangularReflectionMapping
+ THREE.EquirectangularRefractionMapping
+ THREE.CubeUVReflectionMapping
+
+
+
+ Ces constantes définissent le mode de mappage des textures.
+ [page:Constant UVMapping] est la valeur par défaut et mappe la texture en utilisant les coordonnées UV du maillage.
+
+ Les autres définissent les types de mappage d'environnement.
+
+ [page:Constant CubeReflectionMapping] et [page:Constant CubeRefractionMapping] sont à utiliser avec
+ une [page:CubeTexture CubeTexture], qui est composée de six textures, une pour chaque face du cube.
+ [page:Constant CubeReflectionMapping] est la valeur par défaut pour une [page:CubeTexture CubeTexture].
+
+ [page:Constant EquirectangularReflectionMapping] et [page:Constant EquirectangularRefractionMapping]
+ sont à utiliser avec une carte d'environnement équirectangulaire. Aussi appelée carte lat-long, une texture équirectangulaire représente une vue à 360 degrés le long de la ligne médiane horizontale et une vue à 180 degrés le long de la
+ axe vertical, avec les bords supérieur et inférieur de l'image correspondant aux pôles nord et sud
+ d'une sphère cartographiée.
+
+ Voir l'exemple [example:webgl_materials_envmaps materials / envmaps].
+
+ THREE.RepeatWrapping
+ THREE.ClampToEdgeWrapping
+ THREE.MirroredRepeatWrapping
+
+
+ Ces constantes définissent les propriétés des textures [page:Texture.wrapS wrapS] et [page:Texture.wrapT wrapT],
+ qui définissent l'emballage de texture horizontal et vertical.
+
+ Avec [page:constant RepeatWrapping] la texure se répetera simplement à l'infini.
+
+ [page:constant ClampToEdgeWrapping] est la valeur par défaut.
+ Le dernier pixel de la texture s'étend jusqu'au bord du maillage.
+
+ Avec [page:constant MirroredRepeatWrapping] la texure se répetera à l'infini avec un effet mirroir à chaque répétition.
+
+ THREE.NearestFilter
+ THREE.LinearFilter
+
+
+
+ À utiliser avec une propriété de texture [page:Texture.magFilter magFilter],
+ Ces constantes définissent la fonction de grossissement de texture à utiliser lorsque le pixel texturé correspond à une
+ surface inférieure ou égale à un élément de texture (texel).
+
+ [page:constant NearestFilter] renvoie la valeur de l'élément de texture le plus proche
+ (en distance de Manhattan) aux coordonnées de texture spécifiées.
+
+ [page:constant LinearFilter] est la valeur par défaut et renvoie la moyenne pondérée
+ des quatre éléments de texture les plus proches des coordonnées de texture spécifiées,
+ et peut inclure des éléments enveloppés ou répétés à partir d'autres parties d'une texture,
+ en fonction des valeurs de [page:Texture.wrapS wrapS], [page:Texture.wrapT wrapT], et de la cartographie exacte.
+
+ THREE.NearestFilter
+ THREE.NearestMipmapNearestFilter
+ THREE.NearestMipmapLinearFilter
+ THREE.LinearFilter
+ THREE.LinearMipmapNearestFilter
+ THREE.LinearMipmapLinearFilter
+
+
+
+ Pour une utilisation avec la propriété [page:Texture.minFilter minFilter] d'une texture, ces constantes définissent
+ la fonction de minimisation de texture qui est utilisée chaque fois que le pixel texturé est mappé
+ à une zone supérieure à un élément de texture (texel).
+
+
+ En plus de [page:constant NearestFilter] et [page:constant LinearFilter],
+ les quatre fonctions suivantes peuvent être utilisées pour la minification :
+
+ [page:constant NearestMipmapNearestFilter] choisit le mipmap le plus proche qui
+ correspond à la taille du pixel texturé
+ et utilise le critère [page:constant NearestFilter] (le texel le plus proche du
+ centre du pixel) pour produire une valeur de texture.
+
+ [page:constant NearestMipmapLinearFilter] choisit les deux mipmaps les plus proches
+ qui correspondent à la taille du pixel texturé et utilise le critère [page:constant NearestFilter] pour produire
+ une valeur de texture pour chaque mipmap. La valeur de texture finale est une moyenne pondérée de ces deux valeurs.
+
+ [page:constant LinearMipmapNearestFilter] choisit le mipmap qui correspond le mieux
+ la taille du pixel texturé et utilise le critère [page:constant LinearFilter]
+ (une moyenne pondérée des quatre texels les plus proches du centre du pixel)
+ pour produire une valeur de texture.
+
+ [page:constant LinearMipmapLinearFilter] est la valeur par défaut et choisit les deux mipmaps
+ qui correspondent le mieux à la taille du pixel texturé et utilise le critère [page:constant LinearFilter]
+ pour produire une valeur de texture à partir de chaque mipmap. La valeur de texture finale est une moyenne pondérée de ces deux valeurs.
+
+ Voir l'exemple [example:webgl_materials_texture_filters materials / texture / filters].
+
+ THREE.UnsignedByteType
+ THREE.ByteType
+ THREE.ShortType
+ THREE.UnsignedShortType
+ THREE.IntType
+ THREE.UnsignedIntType
+ THREE.FloatType
+ THREE.HalfFloatType
+ THREE.UnsignedShort4444Type
+ THREE.UnsignedShort5551Type
+ THREE.UnsignedInt248Type
+
+
+ À utiliser avec la propriété [page:Texture.type type] d'une texture, qui doit correspondre au format correct. Voir ci-dessous pour plus de détails.
+
+ [page:constant UnsignedByteType] est la valeur par défaut.
+
+ THREE.AlphaFormat
+ THREE.RedFormat
+ THREE.RedIntegerFormat
+ THREE.RGFormat
+ THREE.RGIntegerFormat
+ THREE.RGBAFormat
+ THREE.RGBAIntegerFormat
+ THREE.LuminanceFormat
+ THREE.LuminanceAlphaFormat
+ THREE.DepthFormat
+ THREE.DepthStencilFormat
+
+
+ À utiliser avec la propriété [page:Texture.format format] d'une texture, ceux-ci définissent
+ comment les éléments d'une texture 2d, ou `texels`, sont lus par les shaders.
+
+ [page:constant AlphaFormat] supprime les composants rouge, vert et bleu et lit uniquement le composant alpha.
+
+ [page:constant RedFormat] supprime les composants vert et bleu et lit uniquement le composant rouge.
+
+ [page:constant RedIntegerFormat] supprime les composants vert et bleu et lit uniquement le composant rouge.
+ Les texels sont lus comme des entiers au lieu de points flottants.
+ (ne peut être utilisé qu'avec un contexte de rendu WebGL 2).
+
+
+ [page:constant RGFormat] supprime les composants alpha et bleu et lit les composants rouge et vert.
+ (ne peut être utilisé qu'avec un contexte de rendu WebGL 2).
+
+
+ [page:constant RGIntegerFormat] supprime les composants alpha et bleu et lit les composants rouge et vert.
+ Les texels sont lus comme des entiers au lieu de points flottants.
+ (ne peut être utilisé qu'avec un contexte de rendu WebGL 2).
+
+
+ [page:constant RGBAFormat] est la valeur par défaut et lit les composants rouge, vert, bleu et alpha.
+
+ [page:constant RGBAIntegerFormat] est la valeur par défaut et lit les composants rouge, vert, bleu et alpha.
+ Les texels sont lus comme des entiers au lieu de points flottants.
+ (ne peut être utilisé qu'avec un contexte de rendu WebGL 2).
+
+
+ [page:constant LuminanceFormat] lit chaque élément comme une seule composante de luminance.
+ Celui-ci est ensuite converti en point flottant, fixé dans l'intervalle [0,1], puis assemblé
+ dans un élément RGBA en plaçant la valeur de luminance dans les canaux rouge, vert et bleu,
+ et en assignant 1.0 au canal alpha.
+
+ [page:constant LuminanceAlphaFormat] lit chaque élément comme une composante de luminance/double alpha.
+ Il s'agit du même procédé que pour [page:constant LuminanceFormat], sauf que le canal alpha peut avoir une autre valeur que `1.0`.
+
+ [page:constant DepthFormat] lit chaque élément comme une seule valeur de profondeur, les converti en point flottant, fixé dans l'intervalle [0,1].
+ C'est la valeur par défaut pour [page:DepthTexture DepthTexture].
+
+ [page:constant DepthStencilFormat] lit chaque élément comme une paire de valeurs de profondeur et de gabarit.
+ Le composant de profondeur de la paire est interprété comme dans [page:constant DepthFormat].
+ Le composant de gabarit est interprété en fonction du format interne profondeur + gabarit.
+
+
+ Notez que la texture doit avoir le bon [page:Texture.type type] défini, comme décrit ci-dessus.
+ Voir [link:https://developer.mozilla.org/en/docs/Web/API/WebGLRenderingContext/texImage2D WebGLRenderingContext.texImage2D] pour plus de détails.
+
+ THREE.RGB_S3TC_DXT1_Format
+ THREE.RGBA_S3TC_DXT1_Format
+ THREE.RGBA_S3TC_DXT3_Format
+ THREE.RGBA_S3TC_DXT5_Format
+
+
+ À utiliser avec la propriété [page:Texture.format format] d'une [page:CompressedTexture CompressedTexture],
+ ceux-ci doivent supporter l'extension
+ [link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_s3tc/ WEBGL_compressed_texture_s3tc]
+
+ Il existe 4 formats [link:https://en.wikipedia.org/wiki/S3_Texture_Compression S3TC] disponibles avec cette extension. Ce sont :
+ [page:constant RGB_S3TC_DXT1_Format] : une image compressée DXT1 dans un format d'image RVB.
+ [page:constant RGBA_S3TC_DXT1_Format] : une image compressée DXT1 dans un format d'image RVB avec une simple valeur alpha activée/désactivée.
+ [page:constant RGBA_S3TC_DXT3_Format] : une image compressée DXT3 dans un format d'image RGBA. Comparé à une texture RGBA 32 bits, il offre une compression 4:1.
+ [page:constant RGBA_S3TC_DXT5_Format] : une image compressée DXT5 dans un format d'image RGBA. Il fournit également une compression 4:1, mais diffère de la compression DXT3 dans la façon dont la compression alpha est effectuée.
+
+ THREE.RGB_PVRTC_4BPPV1_Format
+ THREE.RGB_PVRTC_2BPPV1_Format
+ THREE.RGBA_PVRTC_4BPPV1_Format
+ THREE.RGBA_PVRTC_2BPPV1_Format
+
+
+ À utiliser avec la propriété [page:Texture.format format] d'une [page:CompressedTexture CompressedTexture],
+ ceux-ci doivent supporter l'extension [link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_pvrtc/ WEBGL_compressed_texture_pvrtc].
+ Le PVRTC n'est généralement disponible que sur les appareils mobiles équipés de chipsets PowerVR, qui sont principalement des appareils Apple.
+
+ Il existe 4 formats [link:https://en.wikipedia.org/wiki/PVRTC PVRTC] disponibles avec cette extension. Ce sont :
+ [page:constant RGB_PVRTC_4BPPV1_Format] : Compression RVB en mode 4 bits. Un bloc pour chaque 4×4 pixels.
+ [page:constant RGB_PVRTC_2BPPV1_Format] : Compression RVB en mode 2 bits. Un bloc pour chaque 8×4 pixels.
+ [page:constant RGBA_PVRTC_4BPPV1_Format] : Compression RGBA en mode 4 bits. Un bloc pour chaque 4×4 pixels.
+ [page:constant RGBA_PVRTC_2BPPV1_Format] : Compression RGBA en mode 2 bits. Un bloc pour chaque 8×4 pixels.
+
+ THREE.RGB_ETC1_Format
+ THREE.RGB_ETC2_Format
+ THREE.RGBA_ETC2_EAC_Format
+
+
+ À utiliser avec la propriété [page:Texture.format format] d'une [page:CompressedTexture CompressedTexture],
+ ceux-ci doivent supporter les extensions [link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_etc1/ WEBGL_compressed_texture_etc1]
+ (ETC1) ou [link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_etc/ WEBGL_compressed_texture_etc]
+ (ETC2).
+
+ THREE.RGBA_ASTC_4x4_Format
+ THREE.RGBA_ASTC_5x4_Format
+ THREE.RGBA_ASTC_5x5_Format
+ THREE.RGBA_ASTC_6x5_Format
+ THREE.RGBA_ASTC_6x6_Format
+ THREE.RGBA_ASTC_8x5_Format
+ THREE.RGBA_ASTC_8x6_Format
+ THREE.RGBA_ASTC_8x8_Format
+ THREE.RGBA_ASTC_10x5_Format
+ THREE.RGBA_ASTC_10x6_Format
+ THREE.RGBA_ASTC_10x8_Format
+ THREE.RGBA_ASTC_10x10_Format
+ THREE.RGBA_ASTC_12x10_Format
+ THREE.RGBA_ASTC_12x12_Format
+
+
+ À utiliser avec la propriété [page:Texture.format format] d'une [page:CompressedTexture CompressedTexture],
+ ceux-ci doivent supporter les extensions [link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/ WEBGL_compressed_texture_astc].
+
+ THREE.RGBA_BPTC_Format
+
+
+ À utiliser avec la propriété [page:Texture.format format] d'une [page:CompressedTexture CompressedTexture],
+ ceux-ci doivent supporter les extensions [link:https://www.khronos.org/registry/webgl/extensions/EXT_texture_compression_bptc/ EXT_texture_compression_bptc].
+
+ 'ALPHA'
+ 'RGB'
+ 'RGBA'
+ 'LUMINANCE'
+ 'LUMINANCE_ALPHA'
+ 'RED_INTEGER'
+ 'R8'
+ 'R8_SNORM'
+ 'R8I'
+ 'R8UI'
+ 'R16I'
+ 'R16UI'
+ 'R16F'
+ 'R32I'
+ 'R32UI'
+ 'R32F'
+ 'RG8'
+ 'RG8_SNORM'
+ 'RG8I'
+ 'RG8UI'
+ 'RG16I'
+ 'RG16UI'
+ 'RG16F'
+ 'RG32I'
+ 'RG32UI'
+ 'RG32F'
+ 'RGB565'
+ 'RGB8'
+ 'RGB8_SNORM'
+ 'RGB8I'
+ 'RGB8UI'
+ 'RGB16I'
+ 'RGB16UI'
+ 'RGB16F'
+ 'RGB32I'
+ 'RGB32UI'
+ 'RGB32F'
+ 'RGB9_E5'
+ 'SRGB8'
+ 'R11F_G11F_B10F'
+ 'RGBA4'
+ 'RGBA8'
+ 'RGBA8_SNORM'
+ 'RGBA8I'
+ 'RGBA8UI'
+ 'RGBA16I'
+ 'RGBA16UI'
+ 'RGBA16F'
+ 'RGBA32I'
+ 'RGBA32UI'
+ 'RGBA32F'
+ 'RGB5_A1'
+ 'RGB10_A2'
+ 'RGB10_A2UI'
+ 'SRGB8_ALPHA8'
+ 'DEPTH_COMPONENT16'
+ 'DEPTH_COMPONENT24'
+ 'DEPTH_COMPONENT32F'
+ 'DEPTH24_STENCIL8'
+ 'DEPTH32F_STENCIL8'
+
+
+
+
+ Attention : changer le format interne d'une texture n'affectera que le
+ texture lors de l'utilisation d'un contexte de rendu WebGL 2.
+
+ À utiliser avec la propriété de texture [page:Texture.internalFormat internalFormat],
+ ceux-ci définissent comment les éléments d'une texture, ou "texels", sont stockés sur le GPU.
+
+ [page:constante R8] stocke la composante rouge sur 8 bits.
+
+ [page:constant R8_SNORM] stocke la composante rouge sur 8 bits. Le composant est stocké comme normalisé.
+
+ [page:constant R8I] stocke la composante rouge sur 8 bits. Le composant est stocké sous la forme d'un entier.
+
+ [page:constant R8UI] stocke la composante rouge sur 8 bits. Le composant est stocké sous la forme d'un entier non signé.
+
+ [page:constant R16I] stocke la composante rouge sur 16 bits. Le composant est stocké sous la forme d'un entier.
+
+ [page:constant R16UI] stocke la composante rouge sur 16 bits. Le composant est stocké sous la forme d'un entier non signé.
+
+ [page:constant R16F] stocke la composante rouge sur 16 bits. Le composant est stocké en point flottant.
+
+ [page:constant R32I] stocke la composante rouge sur 32 bits. Le composant est stocké sous la forme d'un entier.
+
+ [page:constant R32UI] stocke la composante rouge sur 32 bits. Le composant est stocké sous la forme d'un entier non signé.
+
+ [page:constant R32F] stocke la composante rouge sur 32 bits. Le composant est stocké en point flottant.
+
+ [page:constante RG8] stocke les composantes rouge et verte sur 8 bits chacune.
+
+ [page:constant RG8_SNORM] stocke les composantes rouge et verte sur 8 bits chacune.
+ Chaque composant est stocké comme normalisé.
+
+
+ [page:constant RG8I] stocke les composantes rouge et verte sur 8 bits chacune.
+ Chaque composant est stocké sous la forme d'un entier.
+
+
+ [page:constant RG8UI] stocke les composantes rouge et verte sur 8 bits chacune.
+ Chaque composant est stocké sous la forme d'un entier non signé.
+
+
+ [page:constant RG16I] stocke les composantes rouge et verte sur 16 bits chacune.
+ Chaque composant est stocké sous la forme d'un entier.
+
+
+ [page:constant RG16UI] stocke les composantes rouge et verte sur 16 bits chacune.
+ Chaque composant est stocké sous la forme d'un entier non signé.
+
+
+ [page:constant RG16F] stocke les composantes rouge et verte sur 16 bits chacune.
+ Chaque composant est stocké en point flottant.
+
+
+ [page:constant RG32I] stocke les composantes rouge et verte sur 32 bits chacune.
+ Chaque composant est stocké sous la forme d'un entier.
+
+
+ [page:constant RG32UI] stocke les composantes rouge et verte sur 32 bits.
+ Chaque composant est stocké sous la forme d'un entier non signé.
+
+
+ [page:constante RG32F] stocke les composantes rouge et verte sur 32 bits.
+ Chaque composant est stocké en point flottant.
+
+
+ [page:constant RGB8] stocke les composants rouge, vert et bleu sur 8 bits chacun.
+
+ [page:constant RGB8_SNORM] stocke les composants rouge, vert et bleu sur 8 bits chacun.
+ Chaque composant est stocké comme normalisé.
+
+
+ [page:constant RGB8I] stocke les composants rouge, vert et bleu sur 8 bits chacun.
+ Chaque composant est stocké sous la forme d'un entier.
+
+
+ [page:constant RGB8UI] stocke les composants rouge, vert et bleu sur 8 bits chacun.
+ Chaque composant est stocké sous la forme d'un entier non signé.
+
+
+ [page:constant RGB16I] stocke les composants rouge, vert et bleu sur 16 bits chacun.
+ Chaque composant est stocké sous la forme d'un entier.
+
+
+ [page:constant RGB16UI] stocke les composants rouge, vert et bleu sur 16 bits chacun.
+ Chaque composant est stocké sous la forme d'un entier non signé.
+
+
+ [page:constant RGB16F] stocke les composants rouge, vert et bleu sur 16 bits chacun.
+ Chaque composant est stocké en point flottant
+
+
+ [page:constant RGB32I] stocke les composants rouge, vert et bleu sur 32 bits chacun.
+ Chaque composant est stocké sous la forme d'un entier.
+
+
+ [page:constant RGB32UI] stocke les composants rouge, vert et bleu sur 32 bits chacun.
+ Chaque composant est stocké sous la forme d'un entier non signé.
+
+
+ [page:constant RGB32F] stocke les composants rouge, vert et bleu sur 32 bits chacun.
+ Chaque composant est stocké en point flottant
+
+
+ [page:constante R11F_G11F_B10F] stocke les composantes rouge, verte et bleue respectivement sur 11 bits, 11 bits et 10 bits.
+ Chaque composant est stocké en point flottant.
+
+
+ [page:constant RGB565] stocke les composantes rouge, verte et bleue respectivement sur 5 bits, 6 bits et 5 bits.
+
+ [page:constant RGB9_E5] stocke les composantes rouge, verte et bleue sur 9 bits chacune.
+
+ [page:constant RGBA8] stocke les composants rouge, vert, bleu et alpha sur 8 bits chacun.
+
+ [page:constant RGBA8_SNORM] stocke les composantes rouge, verte, bleue et alpha sur 8 bits.
+ Chaque composant est stocké comme normalisé.
+
+
+ [page:constant RGBA8I] stocke les composants rouge, vert, bleu et alpha sur 8 bits chacun.
+ Chaque composant est stocké sous la forme d'un entier.
+
+
+ [page:constant RGBA8UI] stocke les composants rouge, vert, bleu et alpha sur 8 bits.
+ Chaque composant est stocké sous la forme d'un entier non signé.
+
+
+ [page:constant RGBA16I] stocke les composantes rouge, verte, bleue et alpha sur 16 bits.
+ Chaque composant est stocké sous la forme d'un entier.
+
+
+ [page:constant RGBA16UI] stocke les composants rouge, vert, bleu et alpha sur 16 bits.
+ Chaque composant est stocké sous la forme d'un entier non signé.
+
+
+ [page:constant RGBA16F] stocke les composantes rouge, verte, bleue et alpha sur 16 bits.
+ Chaque composant est stocké en point flottant.
+
+
+ [page:constant RGBA32I] stocke les composantes rouge, verte, bleue et alpha sur 32 bits.
+ Chaque composant est stocké sous la forme d'un entier.
+
+
+ [page:constant RGBA32UI] stocke les composants rouge, vert, bleu et alpha sur 32 bits.
+ Chaque composant est stocké sous la forme d'un entier non signé.
+
+
+ [page:constant RGBA32F] stocke les composantes rouge, verte, bleue et alpha sur 32 bits.
+ Chaque composant est stocké en point flottant.
+
+
+ [page:constant RGB5_A1] stocke les composantes rouge, verte, bleue et alpha respectivement sur 5 bits, 5 bits, 5 bits et 1 bit.
+
+ [page:constant RGB10_A2] stocke les composantes rouge, verte, bleue et alpha respectivement sur 10 bits, 10 bits, 10 bits et 2 bits.
+
+ [page:constant RGB10_A2UI] stocke les composantes rouge, verte, bleue et alpha respectivement sur 10 bits, 10 bits, 10 bits et 2 bits.
+ Chaque composant est stocké sous la forme d'un entier non signé.
+
+
+ [page:constant SRGB8] stocke les composants rouge, vert et bleu sur 8 bits chacun.
+
+ [page:constant SRGB8_ALPHA8] stocke les composants rouge, vert, bleu et alpha sur 8 bits chacun.
+
+ [page : constante DEPTH_COMPONENT16] stocke la composante de profondeur sur 16 bits.
+
+ [page : constante DEPTH_COMPONENT24] stocke la composante de profondeur sur 24 bits.
+
+ [page:constant DEPTH_COMPONENT32F] stocke la composante de profondeur sur 32 bits. Le composant est stocké en point flottant.
+
+ [page:constant DEPTH24_STENCIL8] stocke les composants profondeur et stencil respectivement sur 24 bits et 8 bits.
+ Le composant de gabarit est stocké sous la forme d'un entier non signé.
+
+
+ [page:constant DEPTH32F_STENCIL8] stocke les composants profondeur et stencil respectivement sur 32 bits et 8 bits.
+ Le composant de profondeur est stocké sous forme de point flottant et le composant de gabarit sous forme d'entier non signé.
+
+
+ Notez que la texture doit avoir le bon [page:Texture.type type] défini,
+ ainsi que le bon format [page:Texture.format].
+
+ Voir [link:https://developer.mozilla.org/en/docs/Web/API/WebGLRenderingContext/texImage2D WebGLRenderingContext.texImage2D], et
+ [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/texImage3D WebGL2RenderingContext.texImage3D],
+ pour plus de détails sur une combinaison possible de [page:Texture.format format], [page:Texture.internalFormat internalFormat],
+ et [page:Texture.type type].
+
+ Pour plus d'informations sur les formats internes, vous pouvez également vous référer directement à la
+ [link:https://www.khronos.org/registry/webgl/specs/latest/2.0/ WebGL2 Specification] et
+ à la [link:https://www.khronos.org/registry/OpenGL/specs/es/3.0/es_spec_3.0.pdf OpenGL ES 3.0 Specification].
+
+ THREE.LinearEncoding
+ THREE.sRGBEncoding
+ THREE.BasicDepthPacking
+ THREE.RGBADepthPacking
+
+
+ À utiliser avec une propriété de texture [page:Texture.encoding encoding].
+
+ Si le type d'encodage est modifié après que la texture ait été utilisée par un matériau,
+ vous devrez définir [page:Material.needsUpdate Material.needsUpdate] sur "true" pour que le matériau soit recompilé.
+
+ La valeur par défaut est [page:constant LinearEncoding].
+ Les valeurs autres que celle-ci ne sont valides que pour la carte, envMap et emissiveMap d'un matériau.
+
+ [link:https://github.com/mrdoob/three.js/blob/master/src/constants.js src/constants.js] +
+ + diff --git a/docs/api/fr/geometries/BoxGeometry.html b/docs/api/fr/geometries/BoxGeometry.html index f3f51695473dc0..27719eff69964a 100644 --- a/docs/api/fr/geometries/BoxGeometry.html +++ b/docs/api/fr/geometries/BoxGeometry.html @@ -1,5 +1,5 @@ - +Voir la classe de base [page:BufferGeometry] Pour les méthodes communes.