RuntimeShader Classe

Definizione

[Android.Runtime.Register("android/graphics/RuntimeShader", ApiSince=33, DoNotGenerateAcw=true)]
public class RuntimeShader : Android.Graphics.Shader

[<Android.Runtime.Register("android/graphics/RuntimeShader", ApiSince=33, DoNotGenerateAcw=true)>]
type RuntimeShader = class
    inherit Shader

Ereditarietà

Object

JavaObject

Object

Shader

RuntimeShader

Attributi

RegisterAttribute

Commenti

Un RuntimeShader calcola un colore per pixel in base all'output di una funzione AGSL (Graphics Shading Language) definita dall'utente.

<h3>Android Graphics Shading Language</h3>

La sintassi AGSL è molto simile a OpenGL ES Shading Language, ma esistono alcune importanti differenze evidenziate qui. La maggior parte di queste differenze è sommata in un fatto di base: <b>Con i linguaggi di ombreggiatura GPU, si sta programmando una fase della pipeline GPU. Con AGSL si programma una fase della Canvas pipeline di disegno o RenderNode .</b>

In particolare, un fragment shader GLSL controlla l'intero comportamento della GPU tra il rasterizzatore e l'hardware di fusione. Questo shader esegue tutte le operazioni per calcolare un colore e il colore generato è esattamente ciò che viene alimentato alla fase di fusione della pipeline.

Al contrario, le funzioni AGSL esistono come parte di una pipeline più grande. Quando si esegue un'operazione Canvas di disegno, Android (in genere) assembla un singolo shader di frammento GPU per eseguire tutte le operazioni necessarie. Questo shader include in genere diversi pezzi. Ad esempio, potrebbe includere:

<ul><li>Valutare se un pixel cade all'interno o all'esterno della forma da disegnare (o sul bordo, dove può applicare l'anti-aliasing).</li><>Valutare se un pixel rientra o non rientra nell'area di ritaglio (anche in questo caso, con la possibile logica di anti-aliasing per i pixel del bordo).</li><li>Logic per , ShaderColorFiltere BlendMode in Paint.<Codice di conversione dello spazio colori /li><li>, come parte della gestione dei colori di Android.</li></ul>

Un RuntimeShaderoggetto , come altri Shader tipi, contribuisce in modo efficace a una funzione allo shader del frammento della GPU.

<h3>Esecuzione< shader AGSL/h3>

Proprio come uno shader GLSL, un shader AGSL inizia l'esecuzione in una funzione principale. A differenza di GLSL, la funzione riceve come parametro di input la posizione del pixel all'interno dello Canvas spazio delle coordinate o RenderNode (simile a gl_fragCoord) e restituisce il colore da ombreggiatura come vec4 (simile al colore vec4 o gl_FragColor in GLSL).

vec4 main(vec2 canvas_coordinates);

AGSL e GLSL usano spazi di coordinate diversi per impostazione predefinita. In GLSL la coordinata del frammento (fragCoord) è relativa alla parte inferiore sinistra. AGSL corrisponde al sistema di coordinate dello schermo di Android Canvas che ha l'origine come angolo superiore sinistro. Ciò significa che le coordinate fornite come parametro nella funzione principale sono locali per l'area di disegno, ad eccezione di eventuali Shader#getLocalMatrix(Matrix) trasformazioni applicate a questo shader. Inoltre, se lo shader viene richiamato da un altro tramite #setInputShader(String, Shader), tale shader padre può modificare le coordinate di input in modo arbitrario.

"agsl-and-color-spaces"/><h3>AGSL e Color Spaces</h3>

Android Graphics e per estensione RuntimeShader sono gestiti dal colore. Il funzionamento ColorSpace di un shader AGSL è definito come lo spazio dei colori della destinazione, che nella maggior parte dei casi è determinato da Window#setColorMode(int).

Quando si crea uno shader AGSL, non si saprà qual è lo spazio dei colori funzionante. Per molti effetti, ciò è corretto perché per impostazione predefinita gli input di colore vengono convertiti automaticamente nello spazio dei colori di lavoro. Per alcuni effetti, può essere importante eseguire alcune operazioni matematiche in uno spazio colore fisso e noto. Un esempio comune è l'illuminazione: per ottenere un'illuminazione fisicamente accurata, la matematica deve essere eseguita in uno spazio di colore lineare. A tale scopo, AGSL fornisce due funzioni intrinseche che converte i colori tra lo spazio dei colori di lavoro e lo spazio dei ColorSpace.Named#LINEAR_EXTENDED_SRGB colori:

vec3 toLinearSrgb(vec3 color);
            vec3 fromLinearSrgb(vec3 color);

<h3>AGSL e Premultiplied Alpha</h3>

Quando si tratta di colori trasparenti, esistono due rappresentazioni possibili (comuni): alfa (non associati) e alfa premoltiplicati (associati). In ASGL il colore restituito dalla funzione principale deve essere premoltiplicato. L'uso di AGSL di alfa premoltiplicato implica:

<ul><li>Se lo shader AGSL restituirà colori trasparenti, assicurarsi di moltiplicare rgb per A. Il colore risultante deve essere [R*A, G*A, B*A, A], non [R, G, B, A].</li><li>Per shader più complessi, è necessario comprendere quali dei colori sono premoltiplicati o dritti. Molte operazioni non hanno senso se si combinano entrambi i tipi di colore.</li></ul>

<h3>Uniforms</h3>

AGSL, come GLSL, espone il concetto di uniformi. Un'uniform AGSL viene definita come variabile globale di sola lettura accessibile dal codice AGSL e inizializzata da diversi metodi setter in RuntimeShader. AGSL espone due tipi di dati uniformi primitivi (float, int) e due tipi specializzati (colori, shader) descritti di seguito.

<h4>Primitive Uniforms</h4>

Esistono due tipi uniformi primitivi supportati da AGSL, float e int. Per questi tipi e uniformi che rappresentano un raggruppamento di questi tipi, ad esempio matrici e matrici, sono disponibili metodi corrispondenti RuntimeShader per inizializzarli. <table border="2" width="85%" align="center" cellpadding="5"><thead><tr><th> Java Type</th th><>AGSL Type</th th><>Method</th></tr></thead>

<tbody><tr><td rowspan="4">Floats</td td><>float</td td><>RuntimeShader#setFloatUniform(String, float)</td></tr tr><><td>vec2</td td><td>RuntimeShader#setFloatUniform(String, float, float)<></tr td><><vec3>/td<td><>RuntimeShader#setFloatUniform(String, float, float, float)</tr td/><tr><><td>vec4</td><td>RuntimeShader#setFloatUniform(String, float, float, float, float)</td></tr><><td rowspan="4">Integers</td td><>int</td td><>/tdRuntimeShader#setIntUniform(String, int)<></tr tr><><td>ivec2</td><td>RuntimeShader#setIntUniform(String, int, int)</td></tr tr><><td>ivec3</td td><>RuntimeShader#setIntUniform(String, int, int, int)</><tr td/tr><><td>ivec4</td td/td/trd><>RuntimeShader#setIntUniform(String, int, int, int, int)</td></tr><tr><td rowspan="2">Matrici e matrici</td td><>mat2, mat3 e mat4 e float[]</td><td>RuntimeShader#setFloatUniform(String, float[])</td></tr tr><><td>int[]</td td></td>RuntimeShader#setIntUniform(String, int[])</tr/td></tr></tbody></table>

Ad esempio, un semplice shader AGSL che usa un'uniforme float per modulare la trasparenza del colore di output sarà simile alla seguente:

uniform float alpha;
            vec4 main(vec2 canvas_coordinates) {
                vec3 red = vec3(1.0, 0.0, 0.0);
                return vec4(red * alpha, alpha);
            }

Dopo aver creato un RuntimeShader oggetto con tale programma, l'uniform può essere inizializzato e aggiornato per ogni fotogramma chiamando RuntimeShader#setFloatUniform(String, float) con il valore alfa. Il valore di un'uniform primitiva viene impostato su 0 se viene dichiarato nello shader AGSL ma non inizializzato.

<h4>Uniforms</h4>

AGSL non sa se le variabili uniformi contengono colori, non le convertirà automaticamente nello spazio colori di lavoro dello shader in fase di esecuzione. Tuttavia, puoi etichettare la tua uniforme vec4 con il qualificatore "layout(colore)" che informa Android che l'uniforme verrà usata come colore. In questo modo AGSL può trasformare il valore uniforme nello spazio dei colori di lavoro. In AGSL dichiarare l'uniform come segue:

layout(color) uniform vec4 inputColorA;
            layout(color) uniform vec4 inputColorB;
            vec4 main(vec2 canvas_coordinates) {
                // blend the two colors together and return the resulting color
                return mix(inputColorA, inputColorB, 0.5);
            }

Dopo aver creato un RuntimeShader oggetto con tale programma, è possibile inizializzare e aggiornare le uniformi per ogni fotogramma chiamando RuntimeShader#setColorUniform(String, int), RuntimeShader#setColorUniform(String, long)o RuntimeShader#setColorUniform(String, Color) con i colori desiderati. Il valore di un'uniform di colore non è definito se viene dichiarato nello shader AGSL ma non inizializzato.

<h4 Shader Uniforms>/h4<> In GLSL, un frammento shader può campionarne una trama. Per AGSL invece di campionare le trame è possibile campionare da qualsiasi Shader, incluso ma non limitato a BitmapShader. Per chiarire che si sta operando su un Shader oggetto non esiste alcun metodo "sample". L'uniform shader ha invece un metodo "eval()". Questa distinzione consente agli shader AGSL di campionare da bitmap e shader sfumature esistenti e da altri RuntimeShader oggetti. In AGSL dichiarare l'uniform come segue:

uniform shader myShader;
            vec4 main(vec2 canvas_coordinates) {
                // swap the red and blue color channels when sampling from myShader
                return myShader.eval(canvas_coordinates).bgra;
            }

Dopo aver creato un RuntimeShader oggetto con tale programma, è possibile inizializzare e aggiornare l'uniform dello shader per fotogramma chiamando RuntimeShader#setInputShader(String, Shader) con lo shader desiderato. Il valore di un uniform shader non è definito se viene dichiarato nello shader AGSL ma non inizializzato.

Sebbene la maggior parte BitmapShadercontenga colori che devono essere gestiti dal colore, alcuni contengono dati che non sono effettivamente colori. Sono incluse le bitmap che archiviano normali, proprietà materiali (ad esempio la rugosità), le mappe di altezza o qualsiasi altro dato puramente matematico che si verifica per essere archiviato in una bitmap. Quando si usano questi tipi di shader in AGSL, è probabile che si voglia inizializzarli con #setInputBuffer(String, BitmapShader). Gli shader inizializzati in questo modo funzionano in modo molto simile a un normale BitmapShader (inclusi filtri e tiling), con alcune differenze principali: <ul><li>Nessuna trasformazione dello spazio colore viene applicata (lo spazio colore della bitmap viene ignorato).</li bitmap><>che restituiscono false per Bitmap#isPremultiplied() non vengono premoltiplicate automaticamente.</li></ul>

Inoltre, quando si esegue il campionamento da un BitmapShader oggetto tenere presente che lo shader non usa coordinate normalizzate ,ad esempio una trama in GLSL. Usa (0, 0) nell'angolo superiore sinistro e (larghezza, altezza) nell'angolo inferiore destro. Normalmente, questo è esattamente ciò che vuoi. Se si sta valutando lo shader con coordinate basate su quelle passate al programma AGSL, la scala è corretta. Tuttavia, se si desidera regolare tali coordinate (per eseguire un certo tipo di mapping della bitmap), tenere presente che le coordinate sono locali nell'area di disegno.

per android.graphics.RuntimeShader.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.