RenderNode Classe
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware.
[Android.Runtime.Register("android/graphics/RenderNode", ApiSince=29, DoNotGenerateAcw=true)]
public sealed class RenderNode : Java.Lang.Object[<Android.Runtime.Register("android/graphics/RenderNode", ApiSince=29, DoNotGenerateAcw=true)>]
type RenderNode = class
inherit Object- Ereditarietà
- Attributi
Commenti
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. Ogni RenderNode contiene sia un elenco di visualizzazioni che un set di proprietà che influiscono sul rendering dell'elenco di visualizzazione. I valori RenderNodes vengono usati internamente per tutte le visualizzazioni per impostazione predefinita e in genere non vengono usati direttamente.
RenderNodes viene usato per dividere il contenuto di rendering di una scena complessa in parti più piccole che possono quindi essere aggiornate singolarmente in modo più economico. L'aggiornamento di parte della scena deve solo aggiornare l'elenco di visualizzazione o le proprietà di un numero ridotto di RenderNode invece di ridisegnare tutto da zero. Un oggetto RenderNode richiede solo la registrazione dell'elenco di visualizzazione quando il relativo contenuto deve essere modificato da solo. RenderNodes può anche essere trasformato senza registrare nuovamente l'elenco di visualizzazione tramite le proprietà di trasformazione.
Un editor di testo può ad esempio archiviare ogni paragrafo nel proprio RenderNode. Pertanto, quando l'utente inserisce o rimuove caratteri, è necessario registrare di nuovo solo l'elenco di visualizzazione del paragrafo interessato.
<h3>Accelerazione< hardware/h3>
È possibile disegnare i valori RenderNodes usando un oggetto RecordingCanvas. Non sono supportati nel software. Assicurarsi sempre che l'oggetto android.graphics.Canvas usato per eseguire il rendering di un elenco di visualizzazione sia accelerato dall'hardware tramite android.graphics.Canvas#isHardwareAccelerated().
<h3>Creazione di un oggetto RenderNode</h3>
RenderNode renderNode = new RenderNode("myRenderNode");
renderNode.setPosition(0, 0, 50, 50); // Set the size to 50x50
RecordingCanvas canvas = renderNode.beginRecording();
try {
// Draw with the canvas
canvas.drawRect(...);
} finally {
renderNode.endRecording();
}
<h3>Disegno di un oggetto RenderNode in una visualizzazione</h3>
protected void onDraw(Canvas canvas) {
if (canvas.isHardwareAccelerated()) {
// Check that the RenderNode has a display list, re-recording it if it does not.
if (!myRenderNode.hasDisplayList()) {
updateDisplayList(myRenderNode);
}
// Draw the RenderNode into this canvas.
canvas.drawRenderNode(myRenderNode);
}
}
<h3>Rilascio di risorse</h3>
Questo passaggio non è obbligatorio, ma consigliato se si vogliono rilasciare le risorse contenute in un elenco di visualizzazione il prima possibile. La maggior parte delle bitmap che può contenere.
// Discards the display list content allowing for any held resources to be released.
// After calling this
renderNode.discardDisplayList();
<h3>Proprietà</h3>
Un oggetto RenderNode offre inoltre diverse proprietà, ad esempio #setScaleX(float) o #setTranslationX(float), che possono essere usate per influire su tutti i comandi di disegno registrati all'interno. Ad esempio, queste proprietà possono essere usate per spostarsi in un numero elevato di immagini senza eseguire nuovamente tutte le singole canvas.drawBitmap() chiamate.
private void createDisplayList() {
mRenderNode = new RenderNode("MyRenderNode");
mRenderNode.setPosition(0, 0, width, height);
RecordingCanvas canvas = mRenderNode.beginRecording();
try {
for (Bitmap b : mBitmaps) {
canvas.drawBitmap(b, 0.0f, 0.0f, null);
canvas.translate(0.0f, b.getHeight());
}
} finally {
mRenderNode.endRecording();
}
}
protected void onDraw(Canvas canvas) {
if (canvas.isHardwareAccelerated())
canvas.drawRenderNode(mRenderNode);
}
}
private void moveContentBy(int x) {
// This will move all the bitmaps recorded inside the display list
// by x pixels to the right and redraw this view. All the commands
// recorded in createDisplayList() won't be re-issued, only onDraw()
// will be invoked and will execute very quickly
mRenderNode.offsetLeftAndRight(x);
invalidate();
}
Alcune delle proprietà possono apparire inizialmente ridondanti, ad esempio #setElevation(float) e #setTranslationZ(float). Il motivo di questi duplicati è consentire una separazione tra utilizzi statici & temporanei. Si consideri ad esempio un pulsante che genera da 2dp a 8dp quando viene premuto. A tale scopo, un'applicazione può decidere di impostareElevation(2dip) e quindi premere per animare setTranslationZ su 6dip. Questa combinazione consente di ottenere il valore finale di 8dip desiderato, ma l'animazione deve preoccuparsi solo di animare l'accuratezza dalla pressione senza dover conoscere il valore iniziale iniziale. #setTranslationX(float) e #setTranslationY(float) sono forniti in modo analogo per gli usi di animazione nonostante la sovrapposizione funzionale con #setPosition(Rect).
La matrice di trasformazione di RenderNode viene calcolata in fase di rendering come indicato di seguito:
Matrix transform = new Matrix();
transform.setTranslate(renderNode.getTranslationX(), renderNode.getTranslationY());
transform.preRotate(renderNode.getRotationZ(),
renderNode.getPivotX(), renderNode.getPivotY());
transform.preScale(renderNode.getScaleX(), renderNode.getScaleY(),
renderNode.getPivotX(), renderNode.getPivotY());
La matrice di trasformazione canvas corrente, che viene convertita nella posizione di RenderNode, viene quindi moltiplicata per la matrice di trasformazione di RenderNode. Pertanto, l'ordinamento dei setter di proprietà chiamanti non influisce sul risultato. Questo significa che:
renderNode.setTranslationX(100);
renderNode.setScaleX(100);
Equivale a:
renderNode.setScaleX(100);
renderNode.setTranslationX(100);
<h3>Threading</h3>
RenderNode può essere creato e usato in qualsiasi thread, ma non thread-safe. Solo un singolo thread può interagire con un Oggetto RenderNode in qualsiasi momento. È fondamentale che RenderNode venga usato solo nello stesso thread con cui viene disegnato. Ad esempio, quando si usa RenderNode con una visualizzazione personalizzata, è necessario usare RenderNode solo dal thread dell'interfaccia utente.
<h3>Quando eseguire nuovamente il rendering</h3>
Molti dei metodi di mutazione RenderNode, ad esempio #setTranslationX(float), restituiscono un valore booleano che indica se il valore è effettivamente cambiato o meno. Ciò è utile per rilevare se è necessario eseguire o meno il rendering di un nuovo frame. Un utilizzo tipico sarà simile al seguente:
public void translateTo(int x, int y) {
boolean needsUpdate = myRenderNode.setTranslationX(x);
needsUpdate |= myRenderNode.setTranslationY(y);
if (needsUpdate) {
myOwningView.invalidate();
}
}
Ciò è marginalmente più veloce rispetto all'esecuzione di un controllo iniziale più esplicito se il valore è stato modificato confrontando il valore #getTranslationX() desiderato rispetto a quando riduce al minimo le transizioni JNI. Il meccanismo effettivo di richiesta del rendering di un nuovo frame dipende dalla modalità di disegno di questo oggetto RenderNode. Se viene disegnato in una visualizzazione contenitore, come nel frammento di codice precedente, è sufficiente invalidare tale visualizzazione. Se invece renderNode viene disegnato direttamente in un oggetto Canvas, ad esempio con Surface#lockHardwareCanvas() , è necessario disegnare un nuovo frame chiamando Surface#lockHardwareCanvas(), disegnare di nuovo il renderNode radice o qualsiasi contenuto di primo livello desiderato e infine chiamare Surface#unlockCanvasAndPost(Canvas). </p>
Documentazione java per android.graphics.RenderNode.
Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal Android e usato in base ai termini descritti in 2.5 Attribution License Creative Commons 2.5 Attribution License.
Costruttori
| RenderNode(String) |
Crea un nuovo oggetto RenderNode che può essere utilizzato per registrare batch di operazioni di disegno e archiviare/applicare le proprietà di rendering quando viene disegnato. |
Proprietà
| Alpha |
Restituisce il livello di traslucenza di questo elenco di visualizzazione. |
| AmbientShadowColor |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. |
| Bottom |
Ottiene la posizione inferiore per RenderNode. |
| CameraDistance |
Restituisce la distanza in Z della fotocamera per questo RenderNode |
| Class |
Restituisce la classe di runtime di questo |
| ClipToBounds |
Restituisce un valore che indica se RenderNode sta ritagliando i limiti. |
| ClipToOutline |
Vedere |
| Elevation |
Vedere |
| Handle |
Handle per l'istanza di Android sottostante. (Ereditato da Object) |
| HasDisplayList |
Restituisce un valore che indica se RenderNode dispone di un elenco di visualizzazione. |
| HasIdentityMatrix |
Indica se RenderNode ha o meno una trasformazione di identità. |
| HasOverlappingRendering |
Indica se il contenuto di questo elenco di visualizzazione si sovrappone. |
| HasShadow |
Controlla se RenderNode ha un'ombreggiatura. |
| Height |
Ottiene l'altezza di RenderNode, ovvero la parte inferiore in alto. |
| IsForceDarkAllowed |
Vedere |
| IsPivotExplicitlySet |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. |
| JniIdentityHashCode |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| JniPeerMembers |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. |
| Left |
Ottiene la posizione sinistra per RenderNode. |
| PeerReference |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| PivotX |
Restituisce il valore pivot per questo elenco di visualizzazione sull'asse X, espresso in pixel. |
| PivotY |
Restituisce il valore pivot per questo elenco di visualizzazione sull'asse Y, in pixel. |
| Right |
Ottiene la posizione corretta per RenderNode. |
| RotationX |
Restituisce il valore di rotazione per questo elenco di visualizzazione intorno all'asse X, espresso in gradi. |
| RotationY |
Restituisce il valore di rotazione per questo elenco di visualizzazione intorno all'asse Y, espresso in gradi. |
| RotationZ |
Restituisce il valore di rotazione per questo elenco di visualizzazione intorno all'asse Z, espresso in gradi. |
| ScaleX |
Restituisce il valore di scala per questo elenco di visualizzazione sull'asse X. |
| ScaleY |
Restituisce il valore di scala per questo elenco di visualizzazione sull'asse Y. |
| SpotShadowColor |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. |
| ThresholdClass |
Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da Object) |
| ThresholdType |
Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da Object) |
| Top |
Ottiene la posizione superiore per RenderNode. |
| TranslationX |
Restituisce il valore di conversione per questo elenco di visualizzazione sull'asse X, espresso in pixel. |
| TranslationY |
Restituisce il valore di conversione per questo elenco di visualizzazione sull'asse Y, in pixel. |
| TranslationZ |
Restituisce il valore di traslazione per questo elenco di visualizzazione sull'asse Z. |
| UniqueId |
Restituisce l'ID univoco che identifica il nodo RenderNode. |
| UseCompositingLayer |
Ottiene un valore che indica se è necessario utilizzare o meno un livello di composizione. |
| Width |
Ottiene la larghezza di RenderNode, ovvero a destra a sinistra. |
Metodi
| BeginRecording() |
|
| BeginRecording(Int32, Int32) |
Avvia la registrazione di un elenco di visualizzazione per il nodo di rendering. |
| Clone() |
Crea e restituisce una copia di questo oggetto. (Ereditato da Object) |
| ComputeApproximateMemoryUsage() |
Ottiene l'utilizzo approssimativo della memoria di RenderNode a scopo di debug. |
| DiscardDisplayList() |
Reimpostare le risorse native. |
| Dispose() |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| Dispose(Boolean) |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| EndRecording() |
' Termina la registrazione per questo elenco di visualizzazione. |
| Equals(Object) |
Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object) |
| GetHashCode() |
Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object) |
| GetInverseMatrix(Matrix) |
Ottiene la trasformazione corrente invertita. |
| GetMatrix(Matrix) |
Ottiene la matrice di trasformazione corrente |
| JavaFinalize() |
Chiamato dal Garbage Collector su un oggetto quando Garbage Collection determina che non sono presenti altri riferimenti all'oggetto . (Ereditato da Object) |
| Notify() |
Riattiva un singolo thread in attesa del monitor dell'oggetto. (Ereditato da Object) |
| NotifyAll() |
Riattiva tutti i thread in attesa del monitoraggio di questo oggetto. (Ereditato da Object) |
| OffsetLeftAndRight(Int32) |
Sfalsa le posizioni a sinistra e a destra per RenderNode |
| OffsetTopAndBottom(Int32) |
Esegue l'offset dei valori superiore e inferiore per RenderNode |
| ResetPivot() |
Cancella qualsiasi pivot impostato in precedenza da una chiamata a |
| SetAlpha(Single) |
Imposta il livello di traslucenza per l'elenco di visualizzazione. |
| SetAmbientShadowColor(Color) |
Imposta il colore dell'ombreggiatura ambientale disegnata quando RenderNode ha un valore Z positivo o di elevazione e viene disegnato all'interno di una |
| SetCameraDistance(Single) |
Imposta la distanza lungo l'asse Z (ortogonale sul piano X/Y su cui vengono disegnati RenderNodes) dalla fotocamera a questo RenderNode. |
| SetClipRect(Rect) |
Imposta un clip aggiuntivo sul nodo RenderNode. |
| SetClipToBounds(Boolean) |
Impostare se il nodo Render deve ritagliarsi sui limiti. |
| SetClipToOutline(Boolean) |
Abilita o disabilita il ritaglio nella struttura. |
| SetElevation(Single) |
Imposta l'elevazione di base di questo oggetto RenderNode in pixel |
| SetForceDarkAllowed(Boolean) |
Imposta un valore che indica se consentire o meno l'applicazione di forza scura al nodo RenderNode. |
| SetHandle(IntPtr, JniHandleOwnership) |
Imposta la proprietà Handle. (Ereditato da Object) |
| SetHasOverlappingRendering(Boolean) |
Imposta un valore che indica se l'elenco di visualizzazione esegue il rendering del contenuto che si sovrappone. |
| SetOutline(Outline) |
Imposta la struttura, definendo la forma che esegue il cast di un'ombreggiatura e il percorso da ritagliare se è impostato setClipToOutline. |
| SetPivotX(Single) |
Imposta il valore pivot per l'elenco di visualizzazione sull'asse X |
| SetPivotY(Single) |
Imposta il valore pivot per l'elenco di visualizzazione sull'asse Y |
| SetPosition(Int32, Int32, Int32, Int32) |
Imposta la posizione di RenderNode. |
| SetPosition(Rect) |
Imposta la posizione di RenderNode. |
| SetProjectBackwards(Boolean) |
Imposta un valore che indica se Il nodo RenderNode deve essere disegnato immediatamente dopo il predecessore più vicino RenderNode contenente un ricevitore di proiezione. |
| SetProjectionReceiver(Boolean) |
Imposta un valore che indica se RenderNode è un ricevitore di proiezione. |
| SetRenderEffect(RenderEffect) |
Configurare l'oggetto |
| SetRotationX(Single) |
Imposta il valore di rotazione per l'elenco di visualizzazione attorno all'asse X. |
| SetRotationY(Single) |
Imposta il valore di rotazione per l'elenco di visualizzazione intorno all'asse Y. |
| SetRotationZ(Single) |
Imposta il valore di rotazione per l'elenco di visualizzazione attorno all'asse Z. |
| SetScaleX(Single) |
Imposta il valore di scala per l'elenco di visualizzazione sull'asse X. |
| SetScaleY(Single) |
Imposta il valore di scala per l'elenco di visualizzazione sull'asse Y. |
| SetSpotShadowColor(Color) |
Imposta il colore dell'ombreggiatura spot disegnata quando RenderNode ha un valore Z positivo o di elevazione e viene disegnato all'interno di una |
| SetTranslationX(Single) |
Imposta il valore di traslazione per l'elenco di visualizzazione sull'asse X. |
| SetTranslationY(Single) |
Imposta il valore di conversione per l'elenco di visualizzazione sull'asse Y. |
| SetTranslationZ(Single) |
Imposta il valore di traslazione per l'elenco di visualizzazione sull'asse Z. |
| SetUseCompositingLayer(Boolean, Paint) |
Controlla se forzare o meno il rendering di RenderNode in un buffer intermedio. |
| ToArray<T>() |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| ToString() |
Restituisce una rappresentazione in formato stringa dell'oggetto. (Ereditato da Object) |
| UnregisterFromRuntime() |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| Wait() |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una>notifica</em> o <em>interrotto</em>. (Ereditato da Object) |
| Wait(Int64) |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una notifica</>em> o <em>interrotto</em> o fino a quando non è trascorsa una certa quantità di tempo reale. (Ereditato da Object) |
| Wait(Int64, Int32) |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una notifica</>em> o <em>interrotto</em> o fino a quando non è trascorsa una certa quantità di tempo reale. (Ereditato da Object) |
Implementazioni dell'interfaccia esplicita
| IJavaPeerable.Disposed() |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| IJavaPeerable.DisposeUnlessReferenced() |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| IJavaPeerable.Finalized() |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| IJavaPeerable.JniManagedPeerState |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. (Ereditato da Object) |
Metodi di estensione
| JavaCast<TResult>(IJavaObject) |
Esegue una conversione del tipo verificato dal runtime Android. |
| JavaCast<TResult>(IJavaObject) |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. |
| GetJniTypeName(IJavaPeerable) |
RenderNode viene usato per creare gerarchie di rendering con accelerazione hardware. |