इस पेज का अनुवाद Cloud Translation API से किया गया है.

एजीएसएल क्विक रेफ़रंस

AGSL को GLSL ES 1.0 के साथ काम करने के लिए डिज़ाइन किया गया है. ज़्यादा जानकारी के लिए, OpenGL ES शेडिंग लैंग्वेज के दस्तावेज़ में, मिलता-जुलता फ़ंक्शन देखें. जब भी संभव हो, इस दस्तावेज़ में AGSL और GLSL के बीच के अंतर को बताने की कोशिश की जाती है.

प्रकार

AGSL, GLSL ES 1.0 टाइप के साथ-साथ, वैक्टर और मैट्रिक्स टाइप को दिखाने का एक और तरीका भी इस्तेमाल करता है. AGSL, मध्यम सटीक जानकारी दिखाने के लिए, short और half के अन्य टाइप के साथ काम करता है.

बुनियादी टाइप

टाइप	ब्यौरा
`void`	फ़ंक्शन की कोई रिटर्न वैल्यू नहीं है या पैरामीटर की सूची खाली है. GLSL के उलट, void रिटर्न टाइप के बिना फ़ंक्शन को कोई वैल्यू रिटर्न करनी होगी.
`bool, bvec2, bvec3, bvec4` `(bool2, bool3, bool4)`.	बूलियन स्केलर/वेक्टर
`int, ivec2, ivec3, ivec4` `(int2, int3, int4)`	`highp` साइन वाला इंटिजर/वेक्टर
`float, vec2, vec3, vec4` `(float2, float3, float4)`	`highp` (सिंगल प्रिसिज़न) फ़्लोटिंग पॉइंट स्केलर/वेक्टर
`short, short2, short3, short4`	`mediump int` साइन वाले पूर्णांक/वेक्टर के बराबर
`half, half2, half3, half4`	`mediump float` स्केलर/वेक्टर के बराबर
`mat2, mat3, mat4` `(float2x2, float3x3, float4x4)`	2x2, 3x3, 4x4 `float` मैट्रिक्स
`half2x2, half3x3, half4x4`	`mediump float` मैट्रिक्स टाइप के बराबर

सटीक वैल्यू और रेंज की कम से कम वैल्यू

ये, OpenGL ES 2.0 स्पेसिफ़िकेशन के आधार पर, हर मॉडिफ़ायर के लिए कम से कम सटीक और रेंज की गारंटी है. ज़्यादातर डिवाइसों पर ES 3.0 काम करता है. इसलिए, इनमें highp की सटीक जानकारी/रेंज और int mediump की रेंज ज़्यादा होगी. सटीक वैल्यू देने वाले मॉडिफ़ायर, स्केलर, वेक्टर, और मैट्रिक वैरिएबल और पैरामीटर पर लागू किए जा सकते हैं. यहां दी गई कम से कम वैल्यू ही गारंटी के साथ दी जाती हैं; यह ज़रूरी नहीं है कि lowp, mediump से कम सटीक हो और mediump, highp से कम सटीक हो. फ़िलहाल, AGSL आखिरी आउटपुट में lowp को mediump में बदल देता है.

संशोधक	'फ़्लोट' रेंज	'float' मैग्नीट्यूड की सीमा	'फ़्लोट' प्रीसिज़न	'int' रेंज
highp	$\left\{-2^{62},2^{62}\right\}$	$\left\{2^{-62},2^{62}\right\}$	रिलेटिव: $2^{-16}$	$\left\{-2^{16},2^{16}\right\}$
mediump	$\left\{-2^{14},2^{14}\right\}$	$\left\{2^{-14},2^{14}\right\}$	रिलेटिव: $2^{-10}$	$\left\{-2^{10},2^{10}\right\}$
lowp	$\left\{-2,2\right\}$	$\left\{2^{-8},2\right\}$	एब्सोल्यूट: $2^{-8}$	$\left\{-2^{8},2^{8}\right\}$

ऐरे के अंकों के सबस्क्रिप्ट सिंटैक्स के अलावा, जैसे: var[num], names of vector components for vectors of length 2 - 4 are denoted by a single letter. Components can be swizzled and replicated. ex:vect.yx,vect.yy`

vect.xyzw - पॉइंट/नॉर्मल दिखाने वाले वैक्टर को ऐक्सेस करते समय इस्तेमाल करें

vect.rgba - रंग दिखाने वाले वेक्टर ऐक्सेस करते समय इस्तेमाल करें

vect.LTRB - जब वेक्टर किसी रेक्टैंगल को दिखाता है, तब इसका इस्तेमाल करें (GLSL में नहीं)

AGSL में, 0 और 1 का इस्तेमाल करके उस चैनल में लगातार 0 या 1 जनरेट किया जा सकता है. उदाहरण: vect.rgb1 == vec4(vect.rgb,1)

स्ट्रक्चर और ऐरे

स्ट्रक्चर को GLSL के जैसे ही सिंटैक्स का इस्तेमाल करके एलान किया जाता है. हालांकि, AGSL सिर्फ़ ग्लोबल स्कोप में स्ट्रक्चर के साथ काम करता है.

struct type-name {
 members
} struct-name; // optional variable declaration.

सिर्फ़ एक डाइमेंशन वाले ऐरे का इस्तेमाल किया जा सकता है. साथ ही, ऐरे का साइज़ साफ़ तौर पर बताना ज़रूरी है. इसके लिए, C-स्टाइल या GLSL स्टाइल सिंटैक्स का इस्तेमाल किया जा सकता है:

<base type>[<array size>] वैरिएबल का नाम - उदाहरण: half[10] x;

<base type> वैरिएबल का नाम[<array size>] - उदाहरण: half x[10];

किसी फ़ंक्शन से ऐरे नहीं दिखाए जा सकते, कॉपी नहीं किए जा सकते, असाइन नहीं किए जा सकते या उनकी तुलना नहीं की जा सकती. ऐरे की पाबंदियां, उन स्ट्रक्चर पर भी लागू होती हैं जिनमें ऐरे शामिल होते हैं. ऐरे को सिर्फ़ किसी कॉन्स्टेंट या लूप वैरिएबल का इस्तेमाल करके इंडेक्स किया जा सकता है.

क्वालिफ़ायर

टाइप	ब्यौरा
`const`	कंपाइल-टाइम कॉन्सटेंट या रीड-ओनली फ़ंक्शन पैरामीटर.
`uniform`	प्रोसेस किए जा रहे प्राइमिटिव में वैल्यू नहीं बदलती. `setColorUniform`, `setFloatUniform`, `setIntUniform`, `setInputBuffer`, और `setInputShader` के लिए, RuntimeShader के तरीकों का इस्तेमाल करके, Android से यूनिफ़ॉर्म पास किए जाते हैं.
`in`	फ़ंक्शन में पास किए गए पैरामीटर के लिए. यह डिफ़ॉल्ट विकल्प है.
`out`	पास किए गए फ़ंक्शन पैरामीटर के लिए. फ़ंक्शन की परिभाषा के हिसाब से ही सटीक वैल्यू का इस्तेमाल करना चाहिए.
`inout`	ऐसे पैरामीटर के लिए जिन्हें फ़ंक्शन में डाला और बाहर निकाला जाता है. फ़ंक्शन की परिभाषा के हिसाब से ही सटीक वैल्यू का इस्तेमाल करना चाहिए.

वैरिएबल का एलान

एलान, साफ़ तौर पर ब्रैकेट वाले दायरे में होने चाहिए. यहां दिए गए सैंपल में, y का एलान करने की अनुमति नहीं है:

if (condition)
    int y = 0;

मैट्रिक्स/स्ट्रक्चर/कलेक्शन की बुनियादी बातें

मैट्रिक्स कंस्ट्रक्टर के उदाहरण

जब किसी मैट्रिक को एक ही वैल्यू के साथ बनाया जाता है, तो डायगनल के साथ-साथ सभी वैल्यू को वह वैल्यू दी जाती है. वहीं, बाकी वैल्यू को शून्य दिया जाता है. float2x2(1.0), इसलिए एक 2x2 आइडेंटिटी मैट्रिक बनाएगा.

जब मैट्रिक को कई वैल्यू के साथ बनाया जाता है, तो कॉलम पहले भरे जाते हैं (कॉलम-मेजर ऑर्डर).

ध्यान दें कि GLSL के विपरीत, ऐसे कॉन्स्ट्रक्टर काम नहीं करते जो पास किए गए वैक्टर के कॉम्पोनेंट की संख्या कम करते हैं. हालांकि, एक जैसा असर पाने के लिए, स्विज़लिंग का इस्तेमाल किया जा सकता है. AGSL में vec4 से vec3 बनाने के लिए, vec3 nv = quadVec.xyz तय करें. इससे vec3 का व्यवहार, GLSL में vec4 के व्यवहार जैसा ही होगा.

स्ट्रक्चर कंस्ट्रक्टर का उदाहरण

struct light { float intensity; float3 pos; };
// literal integer constants auto-converted to floating point
light lightVar = light(3, float3(1, 2, 3.0));

मैट्रिक्स कॉम्पोनेंट

ऐरे सबस्क्रिप्शन सिंटैक्स की मदद से, मैट्रिक के कॉम्पोनेंट ऐक्सेस करें.

float4x4 m; // represents a matrix
m[1] = float4(2.0); // sets second column to all 2.0
m[0][0] = 1.0; // sets upper left element to 1.0
m[2][3] = 2.0; // sets 4th element of 3rd column to 2.0

स्ट्रक्चर फ़ील्ड

पीरियड . ऑपरेटर का इस्तेमाल करके, स्ट्रक्चर फ़ील्ड चुनें. ऑपरेटर में ये शामिल हैं:

ऑपरेटर	ब्यौरा
`.`	फ़ील्ड सिलेक्टर
`==, !=`	समानता
`=`	असाइनमेंट

ऐरे के एलिमेंट

ऐरे के एलिमेंट को ऐरे सबस्क्रिप्ट ऑपरेटर [ ] का इस्तेमाल करके ऐक्सेस किया जाता है. उदाहरण के लिए:

diffuseColor += lightIntensity[3] * NdotL;

ऑपरेटर

प्राथमिकता के क्रम में नंबर दिए गए हैं. रिलेशनल और बराबरी के ऑपरेटर > < <= >= == !=, बूलियन वैल्यू देते हैं. वैक्टर के घटकों की तुलना करने के लिए, lessThan(), equal() वगैरह जैसे फ़ंक्शन का इस्तेमाल करें.

	ऑपरेटर	ब्यौरा	असोसिएटिविटी
1	`()`	ब्रैकेट में ग्रुप करना	लागू नहीं
2	`[] () . ++ --`	ऐरे सबस्क्रिप्ट फ़ंक्शन कॉल और कंस्ट्रक्टर स्ट्रक्चर फ़ील्ड या तरीका चुने गए, स्विज़ल पोस्टफ़िक्स में बढ़ोतरी और कम करना	बाएं से दाएं
3	`++ -- + - !`	प्रीफ़िक्स में वैल्यू जोड़ना और घटाना यूनीऐरी	दाएं से बाएं
4	*` /`**	गुणा और भाग करना	बाएं से दाएं
5	`+ -`	जोड़ना और घटाना	बाएं से दाएं
7	`< > <= >=`	रिलेशनल	बाएं से दाएं
8	`== !=`	बराबरी/असमानता	बाएं से दाएं
12	`&&`	लॉजिकल ऐंड	बाएं से दाएं
13	`^^`	लॉजिकल XOR	बाएं से दाएं
14	`\|\|`	लॉजिकल OR	बाएं से दाएं
15	`?\:`	चुनी गई वैल्यू (पूरा ऑपरेंड)	बाएं से दाएं
16	*`= += -= = /=`**	assignment arithmetic assignment arithmetic assignment	बाएं से दाएं
17	`,`	क्रम	बाएं से दाएं

मैट्रिक्स और वेक्टर के ऑपरेशन

स्केलर वैल्यू पर लागू होने पर, अंकगणितीय ऑपरेटर का नतीजा स्केलर होता है. मॉड्यूलो के अलावा, अन्य ऑपरेटर के लिए, अगर एक ऑपरेंड स्केलर है और दूसरा वैक्टर या मैट्रिक्स है, तो ऑपरेशन कॉम्पोनेंट के हिसाब से किया जाता है और नतीजा एक ही तरह का वैक्टर या मैट्रिक्स होता है. अगर दोनों ऑपरेशन एक ही साइज़ के वैक्टर हैं, तो ऑपरेशन को कॉम्पोनेंट के हिसाब से किया जाता है. साथ ही, यह एक ही टाइप का वैक्टर दिखाता है.

कार्रवाई	ब्यौरा
`m = f * m`	स्केलर वैल्यू से मैट्रिक्स को कॉम्पोनेंट-वाइज़ गुणा करना
`v = f * v`	स्केलर वैल्यू से कॉम्पोनेंट के हिसाब से वेक्टर का गुणा करना
`v = v * v`	वेक्टर वैल्यू से कॉम्पोनेंट-वाइज़ वेक्टर का गुणा
`m = m + m`	मैट्रिक्स के कॉम्पोनेंट के हिसाब से जोड़ना
`m = m - m`	मैट्रिक्स के कॉम्पोनेंट के हिसाब से घटाना
`m = m * m`	लीनियर अलजेब्रिक मल्टिप्लाई

अगर एक ऑपरेंड, हमारे मैट्रिक की पंक्ति या कॉलम के साइज़ से मैच करने वाला वेक्टर है, तो गुणा करने वाले ऑपरेटर का इस्तेमाल, अल्जेब्रिक पंक्ति और कॉलम के गुणा करने के लिए किया जा सकता है.

कार्रवाई	ब्यौरा
`m = v * m`	पंक्ति वेक्टर * मैट्रिक्स लीनियर एल्जेब्रिक मल्टीप्लाय
`m = m * v`	मैट्रिक्स * कॉलम वेक्टर लीनियर अल्जीरब्रिक मल्टीप्लाय

वेक्टर डॉट प्रॉडक्ट, क्रॉस प्रॉडक्ट, और घटक के हिसाब से गुणा करने के लिए, पहले से मौजूद फ़ंक्शन का इस्तेमाल करें:

फ़ंक्शन	ब्यौरा
`f = dot(v, v)`	वेक्टर का डॉट प्रॉडक्ट
`v = cross(v, v)`	वेक्टर का क्रॉस प्रॉडक्ट
`m = matrixCompMult(m, m)`	कॉम्पोनेंट के हिसाब से गुणा करना

प्रोग्राम कंट्रोल

फ़ंक्शन कॉल	वैल्यू-रिटर्न के हिसाब से कॉल
इटरेशन	`for (<init>;<test>;<next>)` `{ break, continue }`
चुनें	`if ( ) { }` `if ( ) { } else { }` `switch () { break, case }` - डिफ़ॉल्ट केस आखिर में
कूदना	`break, continue, return` (खारिज करने की अनुमति नहीं है)
एंट्री	`half4 main(float2 fragCoord)`

For लूप की सीमाएं

GLSL ES 1.0 की तरह ही, 'for' लूप का इस्तेमाल काफ़ी सीमित तौर पर किया जा सकता है. साथ ही, यह ज़रूरी है कि कंपाइलर, लूप को अनरोल कर सके. इसका मतलब है कि इनिशलाइज़र, जांच की शर्त, और next स्टेटमेंट में कॉन्स्टेंट का इस्तेमाल करना ज़रूरी है, ताकि कंपाइल करने के समय सभी चीज़ों का हिसाब लगाया जा सके. next स्टेटमेंट में ++, --, +=, or -= का इस्तेमाल ही किया जा सकता है.

पहले से मौजूद फ़ंक्शन

GT (सामान्य टाइप) float, float2, float3, float4 या half, half2, half3, half4 हो सकता है.

इनमें से ज़्यादातर फ़ंक्शन, कॉम्पोनेंट के हिसाब से काम करते हैं. इसका मतलब है कि फ़ंक्शन, हर कॉम्पोनेंट पर लागू होता है. अगर ऐसा नहीं है, तो इसकी जानकारी दी जाती है.

कोण और त्रिकोणमितीय फ़ंक्शन

कोण के तौर पर दिए गए फ़ंक्शन पैरामीटर, रेडियन की इकाइयों में माने जाते हैं. इनमें से किसी भी फ़ंक्शन का इस्तेमाल करने पर, शून्य से भाग देने की गड़बड़ी नहीं होगी. अगर किसी अनुपात के Divisor की वैल्यू 0 है, तो नतीजे तय नहीं होंगे.

फ़ंक्शन	ब्यौरा
`GT radians(GT degrees)`	डिग्री को रेडियन में बदलता है
`GT degrees(GT radians)`	रेडियन को डिग्री में बदलता है
`GT sin(GT angle)`	स्टैंडर्ड साइन
`GT cos(GT angle)`	स्टैंडर्ड कोसाइन
`GT tan(GT angle)`	स्टैंडर्ड टेंगेंट
`GT asin(GT x)`	यह फ़ंक्शन, उस कोण की वैल्यू दिखाता है जिसका साइन x है. यह कोण, $ \left[-{\pi\over 2},{\pi\over 2}\right] $ रेंज में होता है
`GT acos(GT x)`	ऐसा कोण दिखाता है जिसका कोसाइन x है और जो $ \left[0,\pi\right] $ की रेंज में है
`GT atan(GT y, GT x)`	ऐसा कोण दिखाता है जिसका ट्रिगोनोमेट्रिक आर्कटेनजेंट, $ \left[{y\over x}\right] $ है. यह कोण, $ \left[-\pi,\pi\right] $ की रेंज में होता है
`GT atan(GT y_over_x)`	यह एक ऐसा कोण दिखाता है जिसका ट्रिगोनोमेट्रिक आर्कटेंजेंट, `y_over_x` है. यह कोण, $ \left[-{\pi\over 2},{\pi\over 2}\right] $ की रेंज में होता है

घातांकी फ़ंक्शन

फ़ंक्शन	ब्यौरा
`GT pow(GT x, GT y)`	$ x^y $ दिखाता है
`GT exp(GT x)`	$ e^x $ दिखाता है
`GT log(GT x)`	$ ln(x) $ दिखाता है
`GT exp2(GT x)`	$ 2^x $ दिखाता है
`GT log2(GT x)`	$ log_2(x) $ दिखाता है
`GT sqrt(GT x)`	$ \sqrt{x} $ दिखाता है
`GT inversesqrt(GT x)`	$ 1\over{\sqrt{x}} $ दिखाता है

सामान्य फ़ंक्शन

फ़ंक्शन	ब्यौरा
`GT abs(GT x)`	ऐब्सलूट वैल्यू
`GT sign(GT x)`	x के साइन के आधार पर -1.0, 0.0 या 1.0 दिखाता है
`GT floor(GT x)`	सबसे नज़दीक पूर्णांक <= x
`GT ceil(GT x)`	सबसे नज़दीक पूर्णांक >= x
`GT fract(GT x)`	x के फ़्रैक्शनल हिस्से को दिखाता है
`GT mod(GT x, GT y)`	x के मॉड्यूलस y की वैल्यू दिखाता है
`GT mod(GT x, float y)`	x के मॉड्यूलस y की वैल्यू दिखाता है
`GT min(GT x, GT y)`	x या y की सबसे कम वैल्यू दिखाता है
`GT min(GT x, float y)`	x या y की सबसे कम वैल्यू दिखाता है
`GT max(GT x, GT y)`	x या y की सबसे बड़ी वैल्यू दिखाता है
`GT max(GT x, float y)`	x या y की सबसे बड़ी वैल्यू दिखाता है
`GT clamp(GT x, GT` `minVal, GT maxVal)`	यह x को minVal और maxVal के बीच क्लैंप करके दिखाता है.
`GT clamp(GT x, float` `minVal, float maxVal)`	x को minVal और maxVal के बीच क्लैंप करके दिखाता है
`GT saturate(GT x)`	x को 0.0 और 1.0 के बीच क्लैंप करके दिखाता है
`GT mix(GT x, GT y,` `GT a)`	x और y का लीनियर ब्लेंड दिखाता है
`GT mix(GT x, GT y,` `float a)`	x और y का लीनियर ब्लेंड दिखाता है
`GT step(GT edge, GT x)`	अगर x < edge है, तो 0.0 दिखाता है. अगर x > edge है, तो 1.0 दिखाता है
`GT step(float edge,` `GT x)`	अगर x < edge है, तो 0.0 दिखाता है. अगर x > edge है, तो 1.0 दिखाता है
`GT smoothstep(GT edge0,` `GT edge1, GT x)`	edge0 < x < edge1 होने पर, 0 और 1 के बीच हेर्मिट इंटरपोलेशन करता है
`GT smoothstep(float` `edge0, float edge1,` `GT x)`	edge0 < x < edge1 होने पर, 0 और 1 के बीच हेर्मिट इंटरपोलेशन करता है

ज्यामितीय फ़ंक्शन

ये फ़ंक्शन, वैक्टर पर वैक्टर के तौर पर काम करते हैं, न कि कॉम्पोनेंट के हिसाब से. GT, 2 से 4 साइज़ वाले फ़्लोट/हफ़ वेक्टर होते हैं.

फ़ंक्शन	ब्यौरा
`float/half length` `(GT x)`	वेक्टर की लंबाई दिखाता है
`float/half distance(GT` `p0, GT p1)`	बिंदुओं के बीच की दूरी दिखाता है
`float/half dot(GT x,` `GT y)`	डॉट प्रॉडक्ट दिखाता है
`float3/half3` `cross(float3/half3 x,` `float3/half3 y)`	लौटाए गए आइटम का क्रॉस प्रॉडक्ट
`GT normalize(GT x)`	वेक्टर की लंबाई को 1 पर सेट करना
`GT faceforward(GT N,` `GT I, GT Nref)`	अगर dot(Nref, I) < 0 है, तो N दिखाता है. अगर ऐसा नहीं है, तो -N दिखाता है.
`GT reflect(GT I, GT N)`	रिफ़्लेक्शन डायरेक्शन I - 2 * dot(N,I) * N.
`GT refract(GT I, GT N,` `float/half eta)`	रिफ़्रैक्शन वेक्टर दिखाता है

मैट्रिक्स फ़ंक्शन

टाइप मैट, स्क्वेयर मैट्रिक्स का कोई भी टाइप होता है.

फ़ंक्शन	ब्यौरा
`mat matrixCompMult(mat` `x, mat y)`	कॉम्पोनेंट के हिसाब से x को y से गुणा करना
`mat inverse(mat m)`	m का इनवर्स दिखाता है

वेक्टर रिलेशनल फ़ंक्शन

x और y कॉम्पोनेंट के हिसाब से तुलना करें. किसी खास कॉल के लिए, इनपुट और रिटर्न वेक्टर के साइज़ मेल खाने चाहिए. T, इंटिजर और फ़्लोटिंग पॉइंट वेक्टर टाइप का यूनियन है. BV एक बूलियन वेक्टर है, जो इनपुट वेक्टर के साइज़ से मेल खाता है.

फ़ंक्शन	ब्यौरा
`BV lessThan(T x, T y)`	x < y
`BV lessThanEqual(T x,` `T y)`	x <= y
`BV greaterThan(T x,` `T y)`	x > y
`BV greaterThanEqual(T` `x, T y)`	x >= y
`BV equal(T x, T y)`	x == y
`BV equal(BV x, BV y)`	x == y
`BV notEqual(T x, T y)`	x != y
`BV notEqual(BV x,` `BV y)`	x != y
`bool any(BV x)`	`true` अगर x का कोई कॉम्पोनेंट `true` है
`bool all(BV x)`	`true`, अगर x के सभी कॉम्पोनेंट `true` हैं.
`BV not(BV x)`	x का लॉजिकल कॉम्प्लीमेंट

कलर फ़ंक्शन

फ़ंक्शन	ब्यौरा
`vec4 unpremul(vec4` `color)`	कलर वैल्यू को बिना प्रीमल्टीप्लाइड अल्फा में बदलता है
`half3 toLinearSrgb(half3` `color)`	कलर स्पेस को लीनियर SRGB में बदलना
`half3 fromLinearSrgb(half3` `color)`	कलर स्पेस ट्रांसफ़ॉर्मेशन

शेडर सैंपलिंग (मूल्यांकन)

सैंपलर टाइप काम नहीं करते, लेकिन अन्य शेडर का आकलन किया जा सकता है. अगर आपको किसी टेक्सचर का सैंपल चाहिए, तो BitmapShader ऑब्जेक्ट बनाएं और उसे यूनिफ़ॉर्म के तौर पर जोड़ें. ऐसा किसी भी शेडर के लिए किया जा सकता है. इसका मतलब है कि किसी भी Android शेडर का आकलन, उसे पहले बिटमैप में बदले बिना किया जा सकता है. इसमें अन्य RuntimeShader ऑब्जेक्ट भी शामिल हैं. इससे, ज़्यादा सुविधाएं मिलती हैं. हालांकि, कॉम्प्लेक्स शेडर का आकलन करना महंगा हो सकता है, खास तौर पर लूप में.

uniform shader image;

image.eval(coord).a   // The alpha channel from the evaluated image shader

रॉ बफ़र सैंपलिंग

ज़्यादातर इमेज में ऐसे रंग होते हैं जिन्हें कलर मैनेज किया जाना चाहिए.हालांकि, कुछ इमेज में ऐसा डेटा होता है जो असल में रंग नहीं होता. इनमें नॉर्मल, मटीरियल प्रॉपर्टी (जैसे, रफ़नेस), हाइटमैप या इमेज में सेव किया गया पूरी तरह से मैथमैटिकल डेटा शामिल है. AGSL में इस तरह की इमेज का इस्तेमाल करते समय, RuntimeShader#setInputBuffer का इस्तेमाल करके, BitmapShader को सामान्य रॉ बफ़र के तौर पर इस्तेमाल किया जा सकता है. इससे, कलर स्पेस में बदलाव और फ़िल्टर करने की ज़रूरत नहीं पड़ेगी.

संशोधक	'फ़्लोट' रेंज	'float' मैग्नीट्यूड की सीमा	'फ़्लोट' प्रीसिज़न	'int' रेंज
highp	\(\left\{-2^{62},2^{62}\right\}\)	\(\left\{2^{-62},2^{62}\right\}\)	रिलेटिव: \(2^{-16}\)	\(\left\{-2^{16},2^{16}\right\}\)
mediump	\(\left\{-2^{14},2^{14}\right\}\)	\(\left\{2^{-14},2^{14}\right\}\)	रिलेटिव: \(2^{-10}\)	\(\left\{-2^{10},2^{10}\right\}\)
lowp	\(\left\{-2,2\right\}\)	\(\left\{2^{-8},2\right\}\)	एब्सोल्यूट: \(2^{-8}\)	\(\left\{-2^{8},2^{8}\right\}\)