# [name]

Il WebGL rendering mostra le tue scene meravigliosamente realizzate utilizzando [link:https://en.wikipedia.org/wiki/WebGL WebGL].

## Costruttore

### [name]( [param:Object parameters] )

[page:Object parameters] - (opzionale) oggetto con proprietà che definiscono il comportamento del renderer. Il costruttore inoltre non accetta alcun parametro. In tutti i casi, assumerà impostazioni predefinite quando i parametri mancheranno. I seguenti sono parametri validi:
[page:DOMElement canvas] - Un [link:https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas canvas] dove il renderer disegna il suo output. Questo corrisponde alla proprietà [page:WebGLRenderer.domElement domElement] di seguito. Se non viene passato, un nuovo elemento canvas sarà creato.
[page:WebGLRenderingContext context] - Questo può essere utilizzato per collegare il renderer ad un [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext RenderingContext] esistente. Il valore predefinito è `null`.
[page:String precision] - Precisione dello shader. Può essere `"highp"`, `"mediump"` o `"lowp"`. Il valore predefinito è `"highp"` se supportato dal dispositivo.
[page:Boolean alpha] - controlla il valore predefinito di alfa. Quando impostato a `true`, il valore è `0`. Altrimenti è `1`. Il valore predefinito è `false`.
[page:Boolean premultipliedAlpha] - Indica se il renderer presumerà che i colori abbiano [link:https://en.wikipedia.org/wiki/Glossary_of_computer_graphics#Premultiplied_alpha premoltiplicato alfa]. Il valore predefinito è `true`.
[page:Boolean antialias] - Indica se eseguire l'antialiasing. Il valore predefinito è `false`.
[page:Boolean stencil] - Indica se il buffer di disegno ha un [link:https://en.wikipedia.org/wiki/Stencil_buffer buffer stencil] di almeno 8 bit. Il valore predefinito è `false`.
[page:Boolean preserveDrawingBuffer] - Indica se conservare i buffer finché non verranno cancellati o sovrascritti manualmente. Il valore predefinito è `false`.
[page:String powerPreference] - Fornisce un suggerimento allo user agent indicando quale configurazione della GPU è adatta per questo contesto WebGL. Può essere `"high-performance"`, `"low-power"` o `"default"`. Il valore predefinito è `"default"`. Vedi [link:https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.2 WebGL spec] per i dettagli.
[page:Boolean failIfMajorPerformanceCaveat] - Indica se la creazione del renderer avrà esito negativo in caso di rilevamento di prestazioni ridotte. Il valore predefinito è `false`. Vedi [link:https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.2 WebGL spec] per i dettagli.
[page:Boolean depth] - Indica se il buffer di disegno ha un [link:https://en.wikipedia.org/wiki/Z-buffering buffer di depth] di almeno 16 bit. Il valore predefinito è `true`.
[page:Boolean logarithmicDepthBuffer] - Indica se usare un buffer di depth logaritmico. Potrebbe essere necessario utilizzare questa opzione se si ha a che fare con enormi differenze di scala in una singola scena. Si noti che questa impostazione utilizza gl_FragDepth, se disponibile, che disabilita l'ottimizzione [link:https://www.khronos.org/opengl/wiki/Early_Fragment_Test Early Fragment Test] e può causare una riduzione delle prestazioni. Il valore predefinito è `false`. Vedi l'esempio [example:webgl_camera_logarithmicdepthbuffer camera / logarithmicdepthbuffer].

## Proprietà

### [property:Boolean autoClear]

Definisce se il renderer deve cancellare automaticamente il suo output prima di eseguire il rendering di un frame. Il valore predefinito è `true`.

### [property:Boolean autoClearColor]

Se [page:.autoClear autoClear] è `true`, definisce se il renderer deve cancellare il buffer del colore. Il valore predefinito è `true`.

### [property:Boolean autoClearDepth]

Se [page:.autoClear autoClear] è `true`, definisce se il renderer deve cancellare il buffer di depth. Il valore predefinito è `true`.

### [property:Boolean autoClearStencil]

Se [page:.autoClear autoClear] è `true`, definisce se il renderer deve cancellare il buffer dello stencil. Il valore predefinito è `true`.

### [property:Object debug]

- [page:Boolean checkShaderErrors]: Se è `true`, definisce se i programmi material shader devono essere controllati per errori durante la compilazione e il processo di collegamento. Può essere utile disabilitare questo controllo in produzione per aumentare le prestazioni. È fortemente raccomandato mantenere questi controlli attivi durante lo sviluppo. Se lo shader non si compila e non si collega - non funzionerà e il materiale associato non verrà visualizzato. Il valore predefinito è `true`. - [page:Function onShaderError]( gl, program, glVertexShader, glFragmentShader ): A callback function that can be used for custom error reporting. The callback receives the WebGL context, an instance of WebGLProgram as well two instances of WebGLShader representing the vertex and fragment shader. Assigning a custom function disables the default error reporting. Default is `null`.

### [property:Object capabilities]

Un oggetto che contiene i dettagli sulle capacità del [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext RenderingContext] corrente.
- [page:Boolean floatFragmentTextures]: indica se il contesto supporta l'estensione [link:https://developer.mozilla.org/en-US/docs/Web/API/OES_texture_float OES_texture_float].
- [page:Boolean floatVertexTextures]: `true` se [page:Boolean floatFragmentTextures] e [page:Boolean vertexTextures] sono entrambi true.
- [page:Method getMaxAnisotropy](): Restituisce l'anisotropia massima disponibile.
- [page:Method getMaxPrecision](): Restituisce la precisione massima disponibile per gli shader vertex e fragment.
- [page:Boolean isWebGL2]: `true` se il contesto in uso è un oggetto WebGL2RenderingContext.
- [page:Boolean logarithmicDepthBuffer]: `true` se il [page:parameter logarithmicDepthBuffer] era impostato a true nel costruttore e il contesto supporta l'estensione [link:https://developer.mozilla.org/en-US/docs/Web/API/EXT_frag_depth EXT_frag_depth].
- [page:Integer maxAttributes]: Il valore di `gl.MAX_VERTEX_ATTRIBS`.
- [page:Integer maxCubemapSize]: Il valore di `gl.MAX_CUBE_MAP_TEXTURE_SIZE`. Altezza massima * larghezza delle texture della mappa del cubo che uno shader può utilizzare.
- [page:Integer maxFragmentUniforms]: Il valore di `gl.MAX_FRAGMENT_UNIFORM_VECTORS`. Il numero di uniforms che possono essere utilizzate da un fragment shader.
- [page:Integer maxSamples]: Il valore di `gl.MAX_SAMPLES`. Il numero massimo di campioni nel contesto dell'anti-aliasing multicampione (MSAA).
- [page:Integer maxTextureSize]: Il valore di `gl.MAX_TEXTURE_SIZE`. Altezza massima * larghezza di una texture che uno shader utilizza.
- [page:Integer maxTextures]: Il valore di `gl.MAX_TEXTURE_IMAGE_UNITS`. Il numero massimo di texture che possono essere utilizzate da uno shader.
- [page:Integer maxVaryings]: Il valore di `gl.MAX_VARYING_VECTORS`. Il numero di vettori varying che possono essere utilizzati dagli shader.
- [page:Integer maxVertexTextures]: Il valore di `gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS`. Il numero di texture che possono essere utilizzate in un vertex shader.
- [page:Integer maxVertexUniforms]: Il valore di `gl.MAX_VERTEX_UNIFORM_VECTORS`. Il numero massimo di uniforms che possono essere utilizzate in un vertex shader.
- [page:String precision]: La precisione dello shader attualmente utilizzata dal renderer.
- [page:Boolean vertexTextures]: `true` se [property:Integer maxVertexTextures] è maggiore di 0 (ad es. è possibile utilizzare vertex texture).

### [property:Array clippingPlanes]

L'utente definisce piani di taglio specificati come oggetti THREE.Plane nello spazio world. Questi piani si applicano a livello globale. I punti nello spazio il cui prodotto scalare con il piano è negativo vengono tagliati. Il valore predefinito è [].

### [property:DOMElement domElement]

Un [link:https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas canvas] dove il renderer disegna il suo output.
Questo viene automaticamente creato dal renderer nel costruttore (se non è già stato fornito); devi solo aggiungerlo alla tua pagina in questo modo:
`document.body.appendChild( renderer.domElement );`

### [property:Object extensions]

- [page:Object get]( [param:String extensionName] ): Utilizzato per verificare se le varie estensioni sono supportate e restituisce un oggetto con i dettagli dell'estensione se disponibile. Questo metodo può controllare per le seguenti estensioni:

- `WEBGL_depth_texture`
- `EXT_texture_filter_anisotropic`
- `WEBGL_compressed_texture_s3tc`
- `WEBGL_compressed_texture_pvrtc`
- `WEBGL_compressed_texture_etc1`

### [property:string outputColorSpace]

Definisce la codifica di output del renderer. Il valore predefinito è [page:Textures THREE.SRGBColorSpace].

Se il target render è stato impostato utilizzando [page:WebGLRenderer.setRenderTarget .setRenderTarget], verrà invece utilizzato renderTarget.texture.colorSpace.

Vedi la pagina [page:Textures texture constants] per i dettagli su altri formati.

### [property:Object info]

Un oggetto con una serie di informazioni statistiche sulla memoria della scheda grafica e sul processo di rendering. Utile per il debug o solo per curiosità. L'oggetto contiene i seguenti campi:

- memory:
  - geometries
  - textures
- render:
  - calls
  - triangles
  - points
  - lines
  - frame
- programs

Per impostazione predefinita questi dati vengono reimpostati ad ogni chiamata di rendering ma quando si hanno più passaggi di rendering per frame (ad esempio quando si utilizza la post elaborazione) può essere preferibile ripristinare con un modello personalizzato. Inanzitutto, imposta `autoReset` a `false`. `renderer.info.autoReset = false;` Chiama `reset()` ogni volta che hai terminato di renderizzare ogni singolo frame. `renderer.info.reset();`

### [property:Boolean localClippingEnabled]

Definisce se il render rispetta i piani di taglio a livello di oggetto. Il valore predefinito è `false`.

### [property:Object properties]

Utilizzato internamente dal renderer per mantenere traccia delle proprietà dei vari oggetti secondari.

### [property:WebGLRenderLists renderLists]

Utilizzato internamente per gestire l'ordine del rendering degli oggetti della scena.

### [property:WebGLShadowMap shadowMap]

Questo contiene il riferimento alla mappa delle ombre, se utilizzato.
- [page:Boolean enabled]: Se impostato, utilizza le mappe delle ombre nella scena. Il valore predefinito è `false`.
- [page:Boolean autoUpdate]: Abilita aggiornamenti automatici delle ombre nella scena. Il valore predefinito è `true`.
Se non hai bisogno di luci/ombre, puoi impostarlo su `false` quando viene creata un'istanza del renderer.
- [page:Boolean needsUpdate]: Quando impostato a `true`, le mappe delle ombre nella scena verranno aggiornate nella prossima chiamata a `render`. Il valore predefinito è `false`.
Se hai disabilitato gli aggiornamenti automatici alle mappe della ombre (`shadowMap.autoUpdate = false`), avrai bisogno di impostare questo a `true` e poi fare una chiamata a `render` per aggiornare le ombre nella tua scena.
- [page:Integer type]: Definisce il tipo di mappa delle ombre (non filtrato, filtro di chiusura percentuale, filtro di chiusura percentuale con filtro bilineare nello shader). Le opzioni sono:

- THREE.BasicShadowMap
- THREE.PCFShadowMap (default)
- THREE.PCFSoftShadowMap
- THREE.VSMShadowMap

Vedi [page:Renderer Renderer constants] per i dettagli.

### [property:Boolean sortObjects]

Definisce se il renderer deve ordinare gli oggetti. Il valore predefinito è `true`.
Nota: L'ordinamento viene utilizzato per tentare di eseguire correttamente il rendering di oggetti con un certo grado di trasparenza. Per definizione, l'ordinamento degli oggetti potrebbe non funzionare in tutti i casi. A seconda delle esigenze dell'applicazione, potrebbe essere necessario disattivare l'ordinamento e utilizzare altri metodi per gestire il rendering della trasparenza, ad es. determinare manualmente l'ordine di rendering di ciascun oggetto.

### [property:Object state]

Contiene funzioni per settare varie proprietà dello stato [page:WebGLRenderer.context].

### [property:Constant toneMapping]

Il valore predefinito è [page:Renderer NoToneMapping]. Vedi [page:Renderer Renderer constants] per altre scelte.

### [property:Number toneMappingExposure]

Livello della mappatura dei toni. Il valore predefinito è `1`.

### [property:WebXRManager xr]

Fornisce accesso all'[page:WebXRManager interfaccia] relativa al WebXR del renderer.

## Metodi

### [method:undefined clear]( [param:Boolean color], [param:Boolean depth], [param:Boolean stencil] )

Dice al renderer di cancellare il suo colore, il(i) buffer di disegno depth e stancil. Questo metodo inizializza il buffer del colore al valore di color corrente.
Il valore predefinito degli argomenti è `true`.

### [method:undefined clearColor]( )

Cancella il buffer di colore. Equivalente a chiamare [page:WebGLRenderer.clear .clear]( true, false, false ).

### [method:undefined clearDepth]( )

Cancella il buffer di profondità. Equivalente a chiamare [page:WebGLRenderer.clear .clear]( false, true, false ).

### [method:undefined clearStencil]( )

Cancella il buffer di stencil. Equivalente a chiamare [page:WebGLRenderer.clear .clear]( false, false, true ).

### [method:Set compile]( [param:Object3D scene], [param:Camera camera], [param:Scene targetScene] )

Compila tutti i materiali nella scena con la telecamera. Questo è utile per precompilare le ombre prima del primo rendering. Se desideri aggiungere un oggetto 3D a una scena esistente, utilizza il terzo parametro opzionale per applicare la scena di destinazione.
Tieni presente che l'illuminazione della scena deve essere configurata prima di chiamare questo metodo.

### [method:Promise compileAsync]( [param:Object3D scene], [param:Camera camera], [param:Scene targetScene] )

Versione asincrona di [page:WebGLRenderer.compile .compile](). Il metodo restituisce una Promise che si risolve quando è possibile eseguire il rendering di un determinato oggetto 3D o scena senza inutili stalli dovuti alla compilazione dello shader.
Questo metodo utilizza *KHR_parallel_shader_compile*.

### [method:undefined copyFramebufferToTexture]( [param:FramebufferTexture texture], [param:Vector2 position], [param:Number level] )

Copia i pixel dal WebGLFramebuffer corrente in una texture 2D. Abilita l'accesso a [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/copyTexImage2D WebGLRenderingContext.copyTexImage2D].

### [method:undefined copyTextureToTexture]( [param:Texture srcTexture], [param:Texture dstTexture], [param:Box2 srcRegion], [param:Vector2 dstPosition], [param:Number level] )

Copies the pixels of a texture in the bounds '[page:Box2 srcRegion]' in the destination texture starting from the given position. Enables access to [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/texSubImage2D WebGLRenderingContext.texSubImage2D].

### [method:undefined copyTextureToTexture3D]( [param:Texture srcTexture], [param:Texture dstTexture], [param:Box3 srcRegion], [param:Vector3 dstPosition], [param:Number level] )

Copies the pixels of a texture in the bounds '[page:Box3 srcRegion]' in the destination texture starting from the given position. Enables access to [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/texSubImage3D WebGL2RenderingContext.texSubImage3D].

### [method:undefined dispose]( )

Libera le risorse relative alla GPU allocata a questa istanza. Chiama questo metodo ogni volta che questa istanza non viene più utilizzata nella tua applicazione.

### [method:undefined forceContextLoss]()

Simula la perdita del contesto WebGL. Questo richiede il supporto per le estensioni [link:https://developer.mozilla.org/en-US/docs/Web/API/WEBGL_lose_context WEBGL_lose_context].

### [method:undefined forceContextRestore]( )

Simula il ripristino del contesto WebGL. Questo richiede il supporto per le estensioni [link:https://developer.mozilla.org/en-US/docs/Web/API/WEBGL_lose_context WEBGL_lose_context].

### [method:Float getClearAlpha]()

Restituisce un [page:Float float] con l'alfa corrente. Intervallo tra 0 e 1.

### [method:Color getClearColor]( [param:Color target] )

Restituisce un'istanza [page:Color THREE.Color] con l'alfa corrente.

### [method:WebGL2RenderingContext getContext]()

Restituisce il contesto WebGL corrente.

### [method:WebGLContextAttributes getContextAttributes]()

Restituisce un oggetto che descrive gli attributi impostati sul contesto WebGL quando è stato creato.

### [method:Integer getActiveCubeFace]()

Restituisce la faccia del cubo attiva corrente.

### [method:Integer getActiveMipmapLevel]()

Restituisce il livello mipmap attivo corrente.

### [method:RenderTarget getRenderTarget]()

Restituisce il [page:RenderTarget RenderTarget] correnti se ci sono; altrimenti restituisce `null`.

### [method:Vector4 getCurrentViewport]( [param:Vector4 target] )

[page:Vector4 target] — il risultato verrà copiato in questo Vector4.
Restituisce il viewport corrente.

### [method:Vector2 getDrawingBufferSize]( [param:Vector2 target] )

[page:Vector2 target] — il risultato verrà copiato in questo Vector2.
Restituisce la lunghezza e l'altezza del buffer di disegno del renderer, in pixel.

### [method:number getPixelRatio]()

Restituisce il pixel ratio del dispotivo corrente utilizzato.

### [method:Vector4 getScissor]( [param:Vector4 target] )

[page:Vector4 target] — il risultato verrà copiato in questo Vector4.
Restituisce la regione scissor.

### [method:Boolean getScissorTest]()

Restituisce `true` se scissor test è abilitato; altrimenti restituisce `false`.

### [method:Vector2 getSize]( [param:Vector2 target] )

[page:Vector2 target] — il risultato verrà copiato in questo Vector2.
Restituisce la lunghezza e l'altezza del canvas di output del renderer, in pixel.

### [method:Vector4 getViewport]( [param:Vector4 target] )

[page:Vector4 target] — il risultato verrà copiato in questo Vector4.
Restituisce il viewport.

### [method:undefined initTexture]( [param:Texture texture] )

Inizializza la texture data. Utilizzato per precaricare una texture piuttosto che aspettare fino al primo rendering (il quale può causare notevoli ritardi dovuti alla decodifica e al sovraccarico di caricamento della GPU).

### [method:undefined resetGLState]( )

Reimposta lo stato GL al valore predefinito. Chiamato internamente se il contesto WebGL viene perso.

### [method:undefined readRenderTargetPixels]( [param:WebGLRenderTarget renderTarget], [param:Float x], [param:Float y], [param:Float width], [param:Float height], [param:TypedArray buffer], [param:Integer activeCubeFaceIndex] )

buffer - Uint8Array è l'unico tipo di destinazione supportato in tutti i casi, altri tipi dipendono dal renderTarget e dalla piattaforma. Vedi [link:https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.12 WebGL spec] per i dettagli.

Legge le informazioni dei pixel dal renderTarget nel buffer che gli hai passato. Questo è un wrapper attorno a [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/readPixels WebGLRenderingContext.readPixels]().

Vedi l'esempio [example:webgl_interactive_cubes_gpu interactive / cubes / gpu].

Per leggere un [page:WebGLCubeRenderTarget WebGLCubeRenderTarget] utilizzare il parametro opzionale activeCubeFaceIndex per determinare quale faccia deve essere letta.

### [method:undefined render]( [param:Object3D scene], [param:Camera camera] )

Renderizza una [page:Scene scena] o un altro tipo di [page:Object3D oggetto] utilizzando una [page:Camera telecamera].
Il rendering viene seguito su un set [page:WebGLRenderTarget renderTarget] specificato chiamando [page:WebGLRenderer.setRenderTarget .setRenderTarget] o sul canvas come al solito.
Per impostazione predefinita i buffer sono cancellati prima del rendering ma puoi prevenirlo imposstando la proprietà [page:WebGLRenderer.autoClear autoClear] a false. Se vuoi prevenire solo certi buffer dall'essere cancellati puoi impostare le proprietà [page:WebGLRenderer.autoClearColor autoClearColor], [page:WebGLRenderer.autoClearStencil autoClearStencil] o [page:WebGLRenderer.autoClearDepth autoClearDepth] a false. Per cancellare forzatamente uno o più buffer chiama [page:WebGLRenderer.clear .clear].

### [method:undefined resetState]()

Può essere utilizzato per reimpostare lo stato interno WebGL. Questo metodo è principalmente rilevante per applicazioni che condividono un singolo contesto WebGL tra multiple librerie WebGL.

### [method:undefined setAnimationLoop]( [param:Function callback] )

[page:Function callback] — La funzione cancellerà ogni frame disponibile. Se viene passato `null`, si interromperà qualsiasi animazione già in corso.

Una funzione incorporata che può essere utilizzata al posto di [link:https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame requestAnimationFrame]. Questa funzione deve essere utilizza per oggetti WebXR.

### [method:undefined setClearAlpha]( [param:Float alpha] )

Imposta l'alfa. L'input valido è un float tra `0.0` e `1.0`.

### [method:undefined setClearColor]( [param:Color color], [param:Float alpha] )

Imposta il colore e l'opacità.

### [method:undefined setPixelRatio]( [param:number value] )

Imposta la pixel ratio del dispositivo. Questo viene utilizzato per il dispositivo HiDPI per evitare la sfocatura del canvas di output.

### [method:undefined setRenderTarget]( [param:WebGLRenderTarget renderTarget], [param:Integer activeCubeFace], [param:Integer activeMipmapLevel] )

renderTarget -- Il [page:WebGLRenderTarget renderTarget] cha ha bisogno di essere attivato. Quando viene fornito `null`, il canvas invece viene impostato come target di rendering attivo.
activeCubeFace -- Specifica il lato attivo del cubo (PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5) di [page:WebGLCubeRenderTarget]. Quando si passa un [page:WebGLArrayRenderTarget] o [page:WebGL3DRenderTarget] questo indica il livello z in cui eseguire il rendering (opzionale).
activeMipmapLevel -- Specifica il livello mipmap attivo (opzionale).
Questo metodo imposta il renderTarget attivo.

### [method:undefined setScissor]( [param:Integer x], [param:Integer y], [param:Integer width], [param:Integer height] )
[method:undefined setScissor]( [param:Vector4 vector] )

I parametri x, y, lunghezza, e altezza della regione di scissor.
Opzionale, un vettore component-4 che specifica i parametri della regione.
Imposta la regione di scissor da (x, y) a (x + width, y + height).
(x, y) indica l'angolo in basso a sinistra della regione di scissor.

### [method:undefined setScissorTest]( [param:Boolean boolean] )

Abilita o disabilita lo scissor test. Quando questo è abilitato, solo i pixel con l'area di scissor definita saranno influenzati da ulteriori azioni del render.

### [method:undefined setOpaqueSort]( [param:Function method] )

Imposta la funzione di ordinamento opaco per la WebGLRenderLists. Passa null per utilizzare la funzione predefinita painterSortStable.

### [method:undefined setTransparentSort]( [param:Function method] )

Imposta la funzione di ordinamento trasparente per la WebGLRenderLists. Passa null per utilizzare la funzione predefinita reversePainterSortStable.

### [method:undefined setSize]( [param:Integer width], [param:Integer height], [param:Boolean updateStyle] )

Ridimensiona il canvas di output a (width, height) con la pixel ratio del device presa nell'account, e inoltre imposta il viewport per adattarsi a quella dimensione, partendo da (0, 0). Impostando [page:Boolean updateStyle] a false impedisce qualsiasi modifica di stile al canvas di output.

### [method:undefined setViewport]( [param:Integer x], [param:Integer y], [param:Integer width], [param:Integer height] )
[method:undefined setViewport]( [param:Vector4 vector] )

I parametri x, y, lunghezza, e altezza del viewport.
Opzionale, un vettore component-4 che specifica i parametri del viewport.
Imposta il viewport per il rendering da (x, y) a (x + width, y + height).
(x, y) indica l'angolo in basso a sinistra della regione.

## Source

[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]