एजीएसएल को इस तरह से डिज़ाइन किया गया है कि यह GLSL ES 1.0 के साथ काफ़ी हद तक काम करता है. ज़्यादा जानकारी के लिए, यहां समान फ़ंक्शन देखें: OpenGL ES शेडिंग लैंग्वेज दस्तावेज़. इस दस्तावेज़ में, AGSL के बीच के अंतर को कम करने की कोशिश की गई है और GLSL.
प्रकार
एजीएसएल, वेक्टर को दिखाने के दूसरे तरीके के साथ-साथ, GLSL ES 1.0 टाइप के साथ काम करता है
और मैट्रिक्स टाइप. AGSL, दिखाने के लिए अन्य short और half टाइप का इस्तेमाल करता है
मध्यम सटीक.
बुनियादी टाइप
| टाइप | ब्यौरा |
|---|---|
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
| संशोधक | 'फ़्लोट' सीमा | 'फ़्लोट' तीव्रता की सीमा | 'फ़्लोट' प्रिसिज़न | 'इंट' सीमा |
|---|---|---|---|---|
| अच्छी क्वालिटी | \(\left\{-2^{62},2^{62}\right\}\) | \(\left\{2^{-62},2^{62}\right\}\) | मिलता-जुलता: \(2^{-16}\) | \(\left\{-2^{16},2^{16}\right\}\) |
| मीडियम | \(\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 - इसका इस्तेमाल तब करें, जब वेक्टर किसी रेक्टैंगल को दिखाता हो (जीएलएसएल में नहीं)
AGSL में, 0 और 1 का इस्तेमाल करके उस चैनल में कॉन्स्टेंट 0 या 1 बनाया जा सकता है.
उदाहरण: vect.rgb1 == vec4(vect.rgb,1)
स्ट्रक्चर और अरे
स्ट्रक्चर का एलान उसी सिंटैक्स के साथ किया जाता है जो जीएलएसएल के साथ किया जाता है. हालांकि, एजीएसएल सिर्फ़ एजीएसएल के साथ काम करता है में शामिल हैं.
struct type-name {
members
} struct-name; // optional variable declaration.
साफ़ तौर पर जानकारी देने वाला अरे साइज़, सिर्फ़ एक डाइमेंशन वाले सरणियों के साथ काम करता है. इसके लिए, इनका इस्तेमाल किया जाता है सी-स्टाइल या जीएलएसएल स्टाइल सिंटैक्स:
<base type>[<arraysize>] वैरिएबल का नाम - उदाहरण: half[10] x;
<आधार का प्रकार> वैरिएबल का नाम[<arraysize>] - उदाहरण: half x[10];
सरणियों को किसी फ़ंक्शन से लौटाया नहीं जा सकता, उन्हें कॉपी नहीं किया जा सकता, असाइन किया जा सकता है या उनकी तुलना नहीं की जा सकती है. अरे से जुड़ी पाबंदियां, उन स्ट्रक्चर पर लागू होती हैं जिनमें अरे होती हैं. सरणियां यह कर सकती हैं इन्हें सिर्फ़ कॉन्स्टेंट या लूप वैरिएबल का इस्तेमाल करके इंडेक्स किया जाना चाहिए.
क्वालिफ़ायर
| टाइप | ब्यौरा |
|---|---|
const
|
कंपाइल-टाइम कॉन्सटेंट या रीड-ओनली फ़ंक्शन पैरामीटर. |
uniform
|
ओरिजनल डेटा में वैल्यू नहीं बदलती है
प्रोसेस किया जा रहा है.
Android से यूनिफ़ॉर्म पास करने के लिए इनका इस्तेमाल किया जाता है
रनटाइम शेडर
setColorUniform, setFloatUniform,
setIntUniform, setInputBuffer, और
setInputShader. |
in
|
पास-इन फ़ंक्शन पैरामीटर के लिए. यह है डिफ़ॉल्ट. |
out
|
पास-आउट फ़ंक्शन पैरामीटर के लिए. इस्तेमाल करना ज़रूरी है बिलकुल वही सटीक होता है जो फ़ंक्शन की परिभाषा के बराबर होता है. |
inout
|
ऐसे पैरामीटर के लिए जिन्हें पास और आउट, दोनों जगह भेजा जाता है का इस्तेमाल किया जा सकता है. इसे बिलकुल एक समान सटीक जानकारी के साथ इस्तेमाल किया जाना चाहिए फ़ंक्शन की परिभाषा. |
वैरिएबल की जानकारी
एलानों को साफ़ तौर पर ब्रैकेट में रखना चाहिए. इसमें y का एलान
नीचे दिए गए सैंपल की अनुमति नहीं है:
if (condition)
int y = 0;
मैट्रिक्स/स्ट्रक्चर/अरे की बुनियादी बातें
मैट्रिक्स कंस्ट्रक्टर के उदाहरण
जब किसी मैट्रिक्स (आव्यूह) को किसी सिंगल वैल्यू पर बनाया जाता है, तो सभी वैल्यू
डायगनल को वह वैल्यू दी जाती है, जबकि बाकी को शून्य दिया जाता है. float2x2(1.0) यह कर पाते
इसलिए, 2x2 आइडेंटिटी मैट्रिक्स बनाएं.
जब किसी मैट्रिक्स में एक से ज़्यादा वैल्यू हों, तो सबसे पहले कॉलम भरे जाते हैं (कॉलम-मुख्य क्रम).
ध्यान दें कि जीएलएसएल के उलट, कंस्ट्रक्टर जो किसी
पास-इन वेक्टर इस्तेमाल नहीं किया जा सकता, लेकिन स्विज़लिंग का इस्तेमाल करके
इफ़ेक्ट. एजीएसएल में vec4 से vec3 बनाने के लिए, उसी तरीके का इस्तेमाल करें:
GLSL, vec3 nv = quadVec.xyz बताएं.
स्ट्रक्चर कंस्ट्रक्टर का उदाहरण
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 | && |
लॉजिकल AND | बाएं से दाएं |
| 13 | ^^ |
लॉजिकल XOR | बाएं से दाएं |
| 14 | || |
लॉजिकल OR | बाएं से दाएं |
| 15 | ?\:
|
चुना गया (एक पूरा ऑपरेंड) | बाएं से दाएं |
| 16 | = += -= *= /=
|
असाइनमेंट अंकगणित असाइनमेंट अंकगणित असाइनमेंट | बाएं से दाएं |
| 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) |
लूप की सीमाओं के लिए
GLSL ES 1.0 के समान, 'for' लूप की संख्या सीमित है; कंपाइलर ऐसा होना चाहिए
लूप को अनरोल करने के लिए किया जा सकता है. इसका मतलब है कि इनिशलाइज़र, परीक्षण स्थिति, और
next स्टेटमेंट में कॉन्सटेंट का इस्तेमाल होना चाहिए, ताकि कंपाइलेशन में हर चीज़ का कंप्यूट किया जा सके
समय. next स्टेटमेंट, ++, --, +=, or -= का इस्तेमाल करने तक ही सीमित है.
पहले से मौजूद फ़ंक्शन
GT (सामान्य टाइप) float, float2, float3, float4 या
half, half2, half3, half4.
इनमें से ज़्यादातर फ़ंक्शन, कॉम्पोनेंट के हिसाब से काम करते हैं (फ़ंक्शन लागू किया गया प्रति कॉम्पोनेंट). यह नोट किया जाता है, जब ऐसा नहीं होता है.
ऐंगल और त्रिकोणमितीय फलन
किसी ऐंगल के तौर पर बताए गए फ़ंक्शन पैरामीटर, रेडियन की इकाइयों में माने जाते हैं. किसी भी स्थिति में इनमें से किसी भी फ़ंक्शन के नतीजे में शून्य से भाग देने वाली गड़बड़ी नहीं होगी. अगर किसी अनुपात का भाजक 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)
|
वह कोण वापस लौटाता है जिसकी कोसाइन (cos) 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) |
$ nn(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) |
minVal और maxVal के बीच x क्लैंप किया गया रिटर्न दिखाता है. |
GT clamp(GT x, float
minVal, float maxVal) |
minVal और maxVal के बीच जोड़ा गया x लौटाता है |
GT saturate(GT x) |
मान 0.0 और 1.0 के बीच होता है x दिखाता है |
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 < है, तो 0.0 लौटाता है किनारे, अन्य 1.0 |
GT step(float edge,
GT x) |
अगर x < है, तो 0.0 लौटाता है किनारे, अन्य 1.0 |
GT smoothstep(GT edge0,
GT edge1, GT x) |
हर्माइट इंटरपोलेशन करता है 0 और 1 के बीच जब Edge0 < x < एज1 |
GT smoothstep(float
edge0, float edge1,
GT x) |
हर्माइट इंटरपोलेशन करता है 0 और 1 के बीच जब Edge0 < x < एज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) |
N if dot(Nref, I) < वापस लौटाता है 0 या -N. |
GT reflect(GT I, GT N) |
रिफ़्लेक्शन की दिशा I - 2 * डॉट(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 lessThan(T x, T y) |
x < व |
BV lessThanEqual(T x,
T y) |
x <= साल |
BV greaterThan(T x,
T y) |
x > व |
BV greaterThanEqual(T
x, T y) |
x >= साल |
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) |
अगर x का कोई कॉम्पोनेंट true है, तो true |
bool all(BV x) |
अगर x के सभी कॉम्पोनेंट true हैं, तो true. |
BV not(BV x) |
x का लॉजिकल कॉम्प्लिमेंट |
कलर फ़ंक्शन
| फ़ंक्शन | ब्यौरा |
|---|---|
vec4 unpremul(vec4
color) |
यह कलर वैल्यू को पहले से मौजूद न किए गए रंग में बदलता है ऐल्फ़ा |
half3 toLinearSrgb(half3
color) |
कलर स्पेस को लीनियर एसआरजीबी में बदलना |
half3 fromLinearSrgb(half3
color) |
कलर स्पेस ट्रांसफ़ॉर्मेशन |
शेडर सैंपलिंग (आकलन)
सैंपलर टाइप इस्तेमाल नहीं किए जा सकते, लेकिन अन्य शेडर का आकलन किया जा सकता है. अगर आपको नमूना लेने के लिए, आप BitmapShader ऑब्जेक्ट को कॉपी करके उसे यूनिफ़ॉर्म. किसी भी शेडर के लिए ऐसा किया जा सकता है. इसका मतलब है कि आपको सीधे तौर पर किसी भी Android शेडर को बिटमैप पहले, अन्य डेटा सहित RuntimeShader ऑब्जेक्ट. इससे आपको बहुत ज़्यादा लचीला होता है, लेकिन कॉम्प्लेक्स शेडर का इस्तेमाल करना महंगा हो सकता है. एक लूप में, खास तौर पर आकलन करते हैं.
uniform shader image;
image.eval(coord).a // The alpha channel from the evaluated image shader
रॉ बफ़र सैंपलिंग
ज़्यादातर इमेज में ऐसे रंग होते हैं जिन्हें रंगों से मैनेज किया जाना चाहिए. हालांकि, कुछ इमेज के लिए ज़रूरी है कि इसमें ऐसा डेटा शामिल है जो असल में रंग नहीं है. इसमें सामान्य डेटा को स्टोर करने वाली इमेज भी शामिल हैं. मटीरियल प्रॉपर्टी (जैसे, रफ़नेस), हाइटमैप या कोई अन्य पूरी तरह से किसी इमेज में सेव किया जाने वाला गणित का डेटा. इन तरीकों का इस्तेमाल करते समय में से किसी एक को जोड़ना है, तो आप RuntimeShader#setइनपुटBuffer. ऐसा करने से, कलर स्पेस में बदलाव और फ़िल्टर नहीं होगा.