Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
Projection
Una matrice 4×4 per trasformazioni proiettive in 3D.
Descrizione
Una matrice 4×4 utilizzata per trasformazioni proiettive in 3D. Può rappresentare trasformazioni quali traslazione, rotazione, scala, inclinazione e divisione prospettica. È composta da quattro colonne Vector4.
Per trasformazioni puramente lineari (traslazione, rotazione e scala), si consiglia di utilizzare Transform3D, poiché è più performante e richiede meno memoria.
Utilizzata internamente come matrice di proiezione di Camera3D.
Nota: In un contesto booleano, una proiezione sarà valutata come false se è uguale a IDENTITY. Altrimenti, una proiezione sarà valutata sempre come true.
Nota
Ci sono differenze sostanziali quando si usa questa API con C#. Vedi Differenze dell'API C# rispetto a GDScript per maggiori informazioni.
Proprietà
|
||
|
||
|
||
|
Costruttori
Projection(from: Projection) |
|
Projection(from: Transform3D) |
|
Projection(x_axis: Vector4, y_axis: Vector4, z_axis: Vector4, w_axis: Vector4) |
Metodi
create_depth_correction(flip_y: bool) static |
|
create_fit_aabb(aabb: AABB) static |
|
create_for_hmd(eye: int, aspect: float, intraocular_dist: float, display_width: float, display_to_lens: float, oversample: float, z_near: float, z_far: float) static |
|
create_frustum(left: float, right: float, bottom: float, top: float, z_near: float, z_far: float) static |
|
create_frustum_aspect(size: float, aspect: float, offset: Vector2, z_near: float, z_far: float, flip_fov: bool = false) static |
|
create_light_atlas_rect(rect: Rect2) static |
|
create_orthogonal(left: float, right: float, bottom: float, top: float, z_near: float, z_far: float) static |
|
create_orthogonal_aspect(size: float, aspect: float, z_near: float, z_far: float, flip_fov: bool = false) static |
|
create_perspective(fovy: float, aspect: float, z_near: float, z_far: float, flip_fov: bool = false) static |
|
create_perspective_hmd(fovy: float, aspect: float, z_near: float, z_far: float, flip_fov: bool, eye: int, intraocular_dist: float, convergence_dist: float) static |
|
determinant() const |
|
flipped_y() const |
|
get_aspect() const |
|
get_far_plane_half_extents() const |
|
get_fov() const |
|
get_lod_multiplier() const |
|
get_pixels_per_meter(for_pixel_width: int) const |
|
get_projection_plane(plane: int) const |
|
get_viewport_half_extents() const |
|
get_z_far() const |
|
get_z_near() const |
|
inverse() const |
|
is_orthogonal() const |
|
jitter_offseted(offset: Vector2) const |
|
perspective_znear_adjusted(new_znear: float) const |
Operatori
operator !=(right: Projection) |
|
operator *(right: Projection) |
|
operator *(right: Vector4) |
|
operator ==(right: Projection) |
|
operator [](index: int) |
Enumerazioni
enum Planes: 🔗
Planes PLANE_NEAR = 0
Il valore dell'indice del piano di ritaglio vicino della proiezione.
Planes PLANE_FAR = 1
Il valore dell'indice del piano di ritaglio lontano della proiezione.
Planes PLANE_LEFT = 2
Il valore dell'indice del piano di ritaglio sinistro della proiezione.
Planes PLANE_TOP = 3
Il valore dell'indice del piano di ritaglio in alto della proiezione.
Planes PLANE_RIGHT = 4
Il valore dell'indice del piano di ritaglio destro della proiezione.
Planes PLANE_BOTTOM = 5
Il valore dell'indice del piano di ritaglio in basso della proiezione.
Costanti
IDENTITY = Projection(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1) 🔗
Una Projection senza trasformazione definita. Quando applicata ad altre strutture dati, nessuna trasformazione viene eseguita.
ZERO = Projection(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) 🔗
Una Projection con tutti i valori inizializzati a 0. Quando applicati ad altre strutture dati, verranno azzerati.
Descrizioni delle proprietà
Vector4 w = Vector4(0, 0, 0, 1) 🔗
Il vettore W della matrice di proiezione (la colonna 3). Equivalente all'indice di array 3.
Vector4 x = Vector4(1, 0, 0, 0) 🔗
Il vettore X della matrice di proiezione (la colonna 0). Equivalente all'indice di array 0.
Vector4 y = Vector4(0, 1, 0, 0) 🔗
Il vettore Y della matrice di proiezione (la colonna 1). Equivalente all'indice di array 1.
Vector4 z = Vector4(0, 0, 1, 0) 🔗
Il vettore Z della matrice di proiezione (la colonna 2). Equivalente all'indice di array 2.
Descrizioni dei costruttori
Projection Projection() 🔗
Costruisce un Projection predefinito identico a IDENTITY.
Nota: In C#, costruisce un Projection identico a ZERO.
Projection Projection(from: Projection)
Costruisce un Projection come copia del Projection specificato.
Projection Projection(from: Transform3D)
Costruisce una proiezione come copia del Transform3D specificato.
Projection Projection(x_axis: Vector4, y_axis: Vector4, z_axis: Vector4, w_axis: Vector4)
Costruisce una proiezione da quattro valori Vector4 (colonne della matrice).
Descrizioni dei metodi
Projection create_depth_correction(flip_y: bool) static 🔗
Crea una nuova Projection che proietta posizioni da un intervallo di profondità da -1 a 1 a uno che varia da 0 a 1, e capovolge le posizioni proiettate verticalmente, in base al flip_y.
Projection create_fit_aabb(aabb: AABB) static 🔗
Crea una nuova Projection che ridimensiona una determinata proiezione per adattarla a un determinato AABB nello spazio di proiezione.
Projection create_for_hmd(eye: int, aspect: float, intraocular_dist: float, display_width: float, display_to_lens: float, oversample: float, z_near: float, z_far: float) static 🔗
Crea una nuova Projection per proiettare le posizioni su un display montato sulla testa con il rapporto di aspetto X:Y, la distanza tra gli occhi, la larghezza del display, la distanza dalla lente, il fattore di sovracampionamento e i piani di ritaglio della profondità specificati.
eye crea la proiezione per l'occhio sinistro quando impostato su 1, o per l'occhio destro quando impostato su 2.
Projection create_frustum(left: float, right: float, bottom: float, top: float, z_near: float, z_far: float) static 🔗
Crea una nuova Projection che proietta le posizioni in un tronco con i piani di ritaglio specificati.
Projection create_frustum_aspect(size: float, aspect: float, offset: Vector2, z_near: float, z_far: float, flip_fov: bool = false) static 🔗
Crea una nuova Projection che proietta le posizioni in un tronco con le dimensioni, il rapporto di aspetto X:Y, lo scostamento e i piani di ritaglio specificati.
flip_fov determina se il campo visivo della proiezione è capovolto sulla sua diagonale.
Projection create_light_atlas_rect(rect: Rect2) static 🔗
Crea una nuova Projection che proietta le posizioni nel Rect2 specificato.
Projection create_orthogonal(left: float, right: float, bottom: float, top: float, z_near: float, z_far: float) static 🔗
Crea una nuova Projection che proietta le posizioni utilizzando una proiezione ortogonale con i piani di ritaglio specificati.
Projection create_orthogonal_aspect(size: float, aspect: float, z_near: float, z_far: float, flip_fov: bool = false) static 🔗
Crea una nuova Projection che proietta le posizioni attraverso una proiezione ortogonale con le dimensioni, il rapporto di aspetto X:Y e i piani di ritaglio specificati.
flip_fov determina se il campo visivo della proiezione è capovolto sulla sua diagonale.
Projection create_perspective(fovy: float, aspect: float, z_near: float, z_far: float, flip_fov: bool = false) static 🔗
Crea una nuova Projection che proietta le posizioni attraverso una proiezione prospettica con il campo visivo sull'asse Y (in gradi), il rapporto di aspetto X:Y e i piani di ritaglio specificati.
flip_fov determina se il campo visivo della proiezione è capovolto sulla sua diagonale.
Projection create_perspective_hmd(fovy: float, aspect: float, z_near: float, z_far: float, flip_fov: bool, eye: int, intraocular_dist: float, convergence_dist: float) static 🔗
Crea una nuova Projection che proietta le posizioni attraverso una proiezione prospettica con il campo visivo sull'asse Y (in gradi), il rapporto di aspetto X:Y e le distanze di ritaglio specificati. La proiezione è regolata per un display montato sulla testa con la distanza specificata tra gli occhi e la distanza a un punto su cui è possibile mettere a fuoco.
eye crea la proiezione per l'occhio sinistro quando impostato su 1, o per l'occhio destro quando impostato su 2.
flip_fov determina se il campo visivo della proiezione è capovolto sulla sua diagonale.
Restituisce un valore scalare che è il fattore con segno in base al quale le aree sono ridimensionate da questa matrice. Se il segno è negativo, la matrice inverte l'orientamento dell'area.
Il determinante può essere utilizzato per calcolare l'invertibilità di una matrice o risolvere sistemi lineari di equazioni che coinvolgono la matrice, oltre ad altre applicazioni.
Projection flipped_y() const 🔗
Restituisce una copia di questa Projection con i segni dei valori della colonna Y invertiti.
Restituisce il rapporto di aspetto X:Y della viewport di questa Projection.
Vector2 get_far_plane_half_extents() const 🔗
Restituisce le dimensioni del piano di ritaglio lontano della proiezione, divise per due.
Restituisce il campo di vista orizzontale della proiezione (in gradi).
float get_fovy(fovx: float, aspect: float) static 🔗
Restituisce il campo visivo verticale della proiezione (in gradi) associato al campo visivo orizzontale (in gradi) e al rapporto d'aspetto specificati.
Nota: A differenza della maggior parte dei metodi di Projection, ci si aspetta che aspect sia 1 diviso per il rapporto di aspetto X:Y.
float get_lod_multiplier() const 🔗
Restituisce il fattore in base al quale il livello di dettaglio visibile è ridimensionato da questa Projection.
int get_pixels_per_meter(for_pixel_width: int) const 🔗
Restituisce for_pixel_width diviso per la larghezza della viewport misurata in metri sul piano vicino, dopo che questa Projection viene applicata.
Plane get_projection_plane(plane: int) const 🔗
Restituisce il piano di ritaglio di questa Projection il cui indice è dato da plane.
plane dovrebbe essere uguale a uno tra PLANE_NEAR, PLANE_FAR, PLANE_LEFT, PLANE_TOP, PLANE_RIGHT o PLANE_BOTTOM.
Vector2 get_viewport_half_extents() const 🔗
Restituisce le dimensioni del piano della viewport su cui questa Projection proietta le posizioni, divise per due.
Restituisce la distanza per questa Projection oltre la quale le posizioni sono ritagliate.
Restituisce la distanza per questa Projection prima della quale le posizioni sono ritagliate.
Projection inverse() const 🔗
Restituisce una Projection che esegue l'inverso della trasformazione proiettiva di questa Projection.
Restituisce true se questa proiezione esegue una proiezione ortogonale.
Projection jitter_offseted(offset: Vector2) const 🔗
Restituisce una Projection con i valori X e Y del Vector2 specificato aggiunti rispettivamente al primo e al secondo valore della colonna finale.
Projection perspective_znear_adjusted(new_znear: float) const 🔗
Restituisce una Projection con la distanza di ritaglio vicina regolata su new_znear.
Nota: La Projection originale deve essere una proiezione prospettica.
Descrizioni degli operatori
bool operator !=(right: Projection) 🔗
Restituisce true se le proiezioni non sono uguali.
Nota: A causa di errori di precisione in virgola mobile, questo potrebbe restituire true, anche se le proiezioni sono virtualmente uguali. Un metodo is_equal_approx potrebbe essere aggiunto in una futura versione di Godot.
Projection operator *(right: Projection) 🔗
Restituisce una Projection che applica le trasformazioni combinate di questa Projection e right.
Vector4 operator *(right: Vector4) 🔗
Proietta (moltiplica) il Vector4 fornito per questa matrice Projection.
bool operator ==(right: Projection) 🔗
Restituisce true se le proiezioni sono uguali.
Nota: A causa di errori di precisione in virgola mobile, questo potrebbe restituire false, anche se le proiezioni sono virtualmente uguali. Un metodo is_equal_approx potrebbe essere aggiunto in una futura versione di Godot.
Vector4 operator [](index: int) 🔗
Restituisce la colonna della Projection con l'indice specificato.
Gli indici sono nel seguente ordine: x, y, z, w.