Android Graphics Shading Language (AGSL)
Tetap teratur dengan koleksi
Simpan dan kategorikan konten berdasarkan preferensi Anda.
Android Graphics Shading Language (AGSL) digunakan oleh Android 13 dan yang lebih baru untuk
menentukan perilaku objek
RuntimeShader yang dapat diprogram. AGSL
berbagi banyak sintaksisnya dengan shader fragmen GLSL, tetapi berfungsi dalam
sistem rendering grafis Android untuk menyesuaikan paint dalam Canvas
dan memfilter konten View.
Teori operasi
Efek AGSL ada sebagai bagian dari pipeline grafis Android yang lebih besar. Saat
mengeluarkan operasi menggambar yang dipercepat GPU, Android akan menyusun satu shader fragmen
GPU untuk melakukan pekerjaan yang diperlukan. Shader ini biasanya mencakup beberapa bagian.
Misalnya, ini mungkin mencakup:
- Mengevaluasi apakah piksel berada di dalam atau di luar bentuk yang digambar
(atau di batas, yang mungkin menerapkan anti-aliasing).
- Mengevaluasi apakah piksel berada di dalam atau di luar area klip
(sekali lagi, dengan kemungkinan logika anti-aliasing untuk piksel batas).
- Logika untuk
Shader
di Paint. Shader sebenarnya dapat berupa hierarki objek (karena ComposeShader dan fitur lain yang dijelaskan di bawah ini).
- Logika serupa untuk
ColorFilter.
- Menggabungkan kode (untuk jenis
BlendMode tertentu).
- Kode konversi ruang warna, sebagai bagian dari pengelolaan warna Android.
- Jika
Paint memiliki hierarki objek yang kompleks di kolom Shader,
ColorFilter, atau BlendMode, hanya akan ada satu shader fragmen
GPU. Setiap node dalam hierarki tersebut membuat fungsi tunggal. Masing-masing kode {i>clipping<i} dan
kode geometri menciptakan sebuah fungsi. Kode penggabungan dapat membuat fungsi.
Keseluruhan shader fragmen kemudian memanggil semua fungsi tersebut (yang dapat memanggil
fungsi lain, misalnya dalam kasus hierarki shader).
Efek AGSL Anda berkontribusi pada fungsi (atau beberapa fungsi) ke shader fragmen GPU.
Sintaksis dasar
AGSL (dan GLSL) adalah bahasa khusus domain bergaya C. Jenis seperti bool dan
int melacak dengan cermat padanan C-nya; ada jenis tambahan untuk
mendukung vektor dan matriks yang mendukung fungsi domain.
Qualifier dapat diterapkan ke jenis untuk petunjuk presisi dengan cara yang unik untuk bahasa bayangan. Struktur kontrol seperti pernyataan if-else berfungsi mirip seperti di C; bahasa ini juga memberikan dukungan untuk pernyataan switch dan loop for dengan batasan. Beberapa struktur kontrol memerlukan ekspresi konstan yang dapat dievaluasi pada waktu kompilasi.
AGSL mendukung fungsi; setiap program shader dimulai dengan fungsi main.
Fungsi yang ditetapkan pengguna didukung, tanpa dukungan untuk rekursi apa pun.
Fungsi menggunakan konvensi pemanggilan "nilai-nilai"; nilai yang diteruskan ke fungsi disalin ke dalam parameter saat fungsi dipanggil, dan output disalin kembali; ini ditentukan oleh penentu in, out, dan inout.
Konten dan contoh kode di halaman ini tunduk kepada lisensi yang dijelaskan dalam Lisensi Konten. Java dan OpenJDK adalah merek dagang atau merek dagang terdaftar dari Oracle dan/atau afiliasinya.
Terakhir diperbarui pada 2025-07-26 UTC.
[[["Mudah dipahami","easyToUnderstand","thumb-up"],["Memecahkan masalah saya","solvedMyProblem","thumb-up"],["Lainnya","otherUp","thumb-up"]],[["Informasi yang saya butuhkan tidak ada","missingTheInformationINeed","thumb-down"],["Terlalu rumit/langkahnya terlalu banyak","tooComplicatedTooManySteps","thumb-down"],["Sudah usang","outOfDate","thumb-down"],["Masalah terjemahan","translationIssue","thumb-down"],["Masalah kode / contoh","samplesCodeIssue","thumb-down"],["Lainnya","otherDown","thumb-down"]],["Terakhir diperbarui pada 2025-07-26 UTC."],[],[],null,["# Android Graphics Shading Language (AGSL) is used by Android 13 and above to\ndefine the behavior of programmable\n[`RuntimeShader`](/reference/android/graphics/RuntimeShader) objects. AGSL\nshares much of its syntax with GLSL fragment shaders, but works within the\nAndroid graphics rendering system to both customize painting within `Canvas`\nand filter `View` content.\n\nTheory of operation\n-------------------\n\nAGSL effects exist as part of the larger Android graphics pipeline. When Android\nissues a GPU accelerated drawing operation, it assembles a single GPU fragment\nshader to do the required work. This shader typically includes several pieces.\nFor example, it might include:\n\n- Evaluating whether a pixel falls inside or outside of the shape being drawn (or on the border, where it might apply anti-aliasing).\n- Evaluating whether a pixel falls inside or outside of the clipping region (again, with possible anti-aliasing logic for border pixels).\n- Logic for the [`Shader`](/reference/android/graphics/Shader) on the [`Paint`](/reference/android/graphics/Paint). The Shader can actually be a tree of objects (due to [`ComposeShader`](/reference/android/graphics/ComposeShader) and other features described below).\n- Similar logic for the [`ColorFilter`](/reference/android/graphics/ColorFilter).\n- Blending code (for certain types of [`BlendMode`](/reference/android/graphics/BlendMode)).\n- Color space conversion code, as part of Android's color management.\n- When the `Paint` has a complex tree of objects in the `Shader`, `ColorFilter`, or `BlendMode` fields, there is still only a single GPU fragment shader. Each node in that tree creates a single function. The clipping code and geometry code each create a function. The blending code might create a function. The overall fragment shader then calls all of these functions (which may call other functions, e.g. in the case of a shader tree).\n\nYour AGSL effect contributes a function (or functions) to the GPU's fragment shader.\n\nBasic syntax\n------------\n\nAGSL (and GLSL) are C-style domain specific languages. Types such as `bool` and\n`int` closely track their C equivalents; there are additional types to\nsupport vectors and matrices that support domain functionality.\n\nQualifiers can be applied to types for precision hints in a way that's unique to shading languages. Control structures such as `if-else` statements work much\nlike they do in C; the language also provides support for `switch` statements\nand `for` loops with limitations. Some control structures require constant expressions that can be evaluated at compile time.\n\nAGSL supports functions; every shader program begins with the `main` function.\nUser defined functions are supported, without support for recursion of any kind.\nFunctions use a \"value-return\" calling convention; values passed to functions are\ncopied into parameters when the function is called, and outputs are copied\nback; this is determined by the `in`, `out`, and `inout` qualifiers."]]
