RenderScript Runtime API का रेफ़रंस

खास जानकारी

RenderScript, बेहतर परफ़ॉर्मेंस वाला रनटाइम है. यह नेटिव लेवल पर कंप्यूट ऑपरेशन उपलब्ध कराता है. RenderScript कोड, डिवाइसों पर रनटाइम के दौरान कंपाइल किया जाता है, ताकि इसे किसी भी प्लैटफ़ॉर्म पर इस्तेमाल किया जा सके.

इस रेफ़रंस दस्तावेज़ में, RenderScript के रनटाइम एपीआई के बारे में बताया गया है. इनका इस्तेमाल करके, C99 में RenderScript कोड लिखा जा सकता है. RenderScript की हेडर फ़ाइलें, आपके लिए अपने-आप शामिल हो जाती हैं.

RenderScript का इस्तेमाल करने के लिए, आपको यहां दिए गए RenderScript के रनटाइम एपीआई के साथ-साथ, RenderScript के लिए Android फ़्रेमवर्क एपीआई का इस्तेमाल करना होगा. Android फ़्रेमवर्क एपीआई के दस्तावेज़ के लिए, android.renderscript पैकेज का रेफ़रंस देखें.

RenderScript का इस्तेमाल करके डेवलप करने के तरीके और रनटाइम और Android फ़्रेमवर्क एपीआई के इंटरैक्ट करने के तरीके के बारे में ज़्यादा जानने के लिए, RenderScript डेवलपर गाइड और RenderScript के सैंपल देखें.

संख्याओं के टाइप

स्केलर:

RenderScript, स्केलर संख्याओं के इन टाइप के साथ काम करता है:

	8 बिट	16 बिट	32 बिट	64 बिट
पूर्णांक:	char, int8_t	short, int16_t	int32_t	long, long long, int64_t
बिना साइन वाला पूर्णांक:	uchar, uint8_t	ushort, uint16_t	uint, uint32_t	ulong, uint64_t
फ़्लोटिंग पॉइंट:		हाफ़	फ़्लोट	डबल

वेक्टर:

RenderScript, तय साइज़ के वेक्टर के साथ काम करता है. इन वेक्टर की लंबाई 2, 3, और 4 हो सकती है. वेक्टर को सामान्य टाइप के नाम का इस्तेमाल करके डिक्लेयर्ड किया जाता है. इसके बाद, 2, 3 या 4 का इस्तेमाल किया जाता है. उदाहरण के लिए, float4, int3, double2, ulong4.

वैक्टर लिटरल बनाने के लिए, वैक्टर टाइप के बाद कर्ली ब्रैकेट के बीच वैल्यू डालें, जैसे कि (float3){1.0f, 2.0f, 3.0f}.

किसी वेक्टर की एंट्री को नाम देने के अलग-अलग स्टाइल का इस्तेमाल करके ऐक्सेस किया जा सकता है.

वैरिएबल के नाम के बाद बिंदु लगाकर, सिंगल एंट्री को ऐक्सेस किया जा सकता है. इसके लिए:

• x, y, z, और w अक्षर,
• r, g, b, और a अक्षर,
• s या S अक्षर के बाद, शून्य पर आधारित इंडेक्स.

उदाहरण के लिए, int4 myVar; के साथ ये एक जैसे हैं:
myVar.x == myVar.r == myVar.s0 == myVar.S0
myVar.y == myVar.g == myVar.s1 == myVar.S1
myVar.z == myVar.b == myVar.s2 == myVar.S2
myVar.w == myVar.a == myVar.s3 == myVar.S3

एक से ज़्यादा अक्षरों या इंडेक्स को जोड़कर बनाए गए आइडेंटिफ़ायर का इस्तेमाल करके, एक वेक्टर की कई एंट्री को एक साथ ऐक्सेस किया जा सकता है. इस वेक्टर का साइज़, नाम वाली एंट्री की संख्या के बराबर होता है.

ऊपर दिए गए उदाहरण में, बीच की दो एंट्री को myVar.yz, myVar.gb, myVar.s12, और myVar.S12 का इस्तेमाल करके ऐक्सेस किया जा सकता है.

एंट्री, एक-दूसरे के बगल में या बढ़ते क्रम में होनी ज़रूरी नहीं है. एंट्री को तब तक दोहराया जा सकता है, जब तक हम उन्हें असाइन नहीं कर रहे हैं. नाम रखने के अलग-अलग स्टाइल भी नहीं इस्तेमाल किए जा सकते.

यहां कुछ उदाहरण दिए गए हैं. इनसे पता चलता है कि क्या किया जा सकता है और क्या नहीं:
float4 v4;
float3 v3;
float2 v2;
v2 = v4.xx; // Valid
v3 = v4.zxw; // Valid
v3 = v4.bba; // Valid
v3 = v4.s032; // Valid
v3.s120 = v4.S233; // Valid
v4.yz = v3.rg; // Valid
v4.yzx = v3.rg; // Invalid: mismatched sizes
v4.yzz = v3; // Invalid: z appears twice in an assignment
v3 = v3.xas0; // Invalid: can't mix xyzw with rgba nor s0...
v3 = v4.s034; // Invalid: the digit can only be 0, 1, 2, or 3


मैट्रिक्स और क्वार्टरनियन:

RenderScript, 2x2, 3x3, और 4x4 साइज़ के फ़्लोट के फ़िक्स साइज़ स्क्वेयर मैट्रिक्स के साथ काम करता है. इन टाइप का नाम rs_matrix2x2, rs_matrix3x3, और rs_matrix4x4 है. ऑपरेशन की सूची के लिए, मैट्रिक फ़ंक्शन देखें.

rs_quaternion के ज़रिए भी क्वार्टरनियन का इस्तेमाल किया जा सकता है. कार्रवाइयों की सूची के लिए, क्वार्टरन फ़ंक्शन देखें.

प्रकार
char2	दो 8-बिट साइन वाले इंटिजर
char3	तीन 8-बिट साइन किए गए इंटिजर
char4	चार 8-बिट साइन वाले इंटिजर
double2	दो 64 बिट फ़्लोट
double3	तीन 64 बिट फ़्लोट
double4	चार 64-बिट फ़्लोट
float2	दो 32-बिट फ़्लोट
float3	तीन 32-बिट फ़्लोट
float4	चार 32-बिट फ़्लोट
आधा	16-बिट फ़्लोटिंग पॉइंट वैल्यू
half2	दो 16-बिट फ़्लोट
half3	तीन 16-बिट फ़्लोट
half4	चार 16-बिट फ़्लोट
int16_t	16 बिट का साइन वाला इंटिजर
int2	दो 32-बिट साइन किए गए इंटिजर
int3	तीन 32-बिट साइन किए गए इंटिजर
int32_t	32 बिट का साइन वाला इंटिजर
int4	चार 32-बिट के साइन किए गए इंटिजर
int64_t	64 बिट का साइन वाला इंटिजर
int8_t	8 बिट का साइन वाला इंटिजर
long2	दो 64 बिट के साइन किए गए इंटिजर
long3	तीन 64-बिट साइन वाले इंटिजर
long4	चार 64-बिट साइन वाले इंटिजर
rs_matrix2x2	32-बिट फ़्लोट की 2x2 मैट्रिक्स
rs_matrix3x3	32-बिट फ़्लोट की 3x3 मैट्रिक्स
rs_matrix4x4	32-बिट फ़्लोट का 4x4 मैट्रिक्स
rs_quaternion	क्वार्टरन
short2	दो 16-बिट साइन किए गए इंटिजर
short3	तीन 16-बिट साइन किए गए इंटिजर
short4	चार 16-बिट साइन किए गए इंटिजर
size_t	साइन न किए गए साइज़ का टाइप
ssize_t	साइन किया गया साइज़ टाइप
uchar	बिना हस्ताक्षर वाला 8-बिट इंटिजर
uchar2	दो 8-बिट के बिना हस्ताक्षर वाले पूर्णांक
uchar3	तीन 8-बिट के बिना हस्ताक्षर वाले पूर्णांक
uchar4	चार 8-बिट बिना हस्ताक्षर वाले पूर्णांक
uint	32 बिट का बिना हस्ताक्षर वाला पूर्णांक
uint16_t	16 बिट का बिना हस्ताक्षर वाला इंटिजर
uint2	दो 32-बिट के बिना हस्ताक्षर वाले पूर्णांक
uint3	तीन 32-बिट के बिना हस्ताक्षर वाले पूर्णांक
uint32_t	32 बिट का बिना हस्ताक्षर वाला पूर्णांक
uint4	चार 32-बिट के बिना हस्ताक्षर वाले पूर्णांक
uint64_t	64 बिट का बिना हस्ताक्षर वाला पूर्णांक
uint8_t	बिना हस्ताक्षर वाला 8-बिट इंटिजर
ulong	64 बिट का बिना हस्ताक्षर वाला पूर्णांक
ulong2	दो 64-बिट बिना हस्ताक्षर वाले पूर्णांक
ulong3	तीन 64-बिट बिना हस्ताक्षर वाले इंटिजर
ulong4	चार 64-बिट बिना हस्ताक्षर वाले पूर्णांक
ushort	16 बिट का बिना हस्ताक्षर वाला इंटिजर
ushort2	दो 16-बिट के बिना हस्ताक्षर वाले इंटिजर
ushort3	तीन 16-बिट बिना हस्ताक्षर वाले पूर्णांक
ushort4	चार 16-बिट के बिना हस्ताक्षर वाले इंटिजर

ऑब्जेक्ट टाइप

नीचे दिए गए टाइप का इस्तेमाल, RenderScript ऑब्जेक्ट में बदलाव करने के लिए किया जाता है. जैसे, एलोकेशन, सैंपलर, एलिमेंट, और स्क्रिप्ट. इनमें से ज़्यादातर ऑब्जेक्ट, Java RenderScript API का इस्तेमाल करके बनाए जाते हैं.

प्रकार
rs_allocation	किसी ऐलोकेशन का हैंडल
rs_allocation_cubemap_face	क्यूब मैप के फ़ेस चुनने के लिए Enum
rs_allocation_usage_type	बिटफ़ील्ड, जिससे यह पता चलता है कि किसी ऐलोकेशन का इस्तेमाल कैसे किया जाता है
rs_data_kind	एलिमेंट का डेटा टाइप
rs_data_type	एलिमेंट का बुनियादी डेटा टाइप
rs_element	किसी एलिमेंट का हैंडल
rs_sampler	सैंपलर का हैंडल
rs_sampler_value	सैंपलर रैप T वैल्यू
rs_script	स्क्रिप्ट का हैंडल
rs_type	किसी टाइप का हैंडल
rs_yuv_format	YUV फ़ॉर्मैट

कन्वर्ज़न फ़ंक्शन

नीचे दिए गए फ़ंक्शन, संख्या वाले वेक्टर टाइप को एक से दूसरे में या एक रंग के प्रतिनिधित्व को दूसरे में बदलते हैं.

फ़ंक्शन
बदलें	संख्या वाले वेक्टर बदलना
rsPackColorTo8888	फ़्लोट से uchar4 RGBA बनाना
rsUnpackColor8888	uchar4 से float4 RGBA बनाना
rsYuvToRGBA	YUV वैल्यू को आरजीबीए में बदलना

गणितीय स्थिरांक और फ़ंक्शन

नीचे दिए गए गणितीय फ़ंक्शन, स्केलर और वैक्टर पर लागू किए जा सकते हैं. वैक्टर पर लागू करने पर, रिटर्न की गई वैल्यू, इनपुट की हर एंट्री पर लागू किए गए फ़ंक्शन का वैक्टर होती है.

उदाहरण के लिए:
float3 a, b;
// The following call sets
// a.x to sin(b.x),
// a.y to sin(b.y), and
// a.z to sin(b.z).
a = sin(b);


distance() और length() जैसे फ़ंक्शन के लिए वेक्टर मैथ फ़ंक्शन देखें. ये फ़ंक्शन, इनपुट को n-डाइमेंशनल स्पेस में एक वेक्टर के तौर पर समझते हैं.

32 बिट फ़्लोट पर किए जाने वाले गणितीय ऑपरेशन के सटीक होने पर, pragmas rs_fp_relaxed और rs_fp_full का असर पड़ता है. rs_fp_relaxed के तहत, सब-नॉर्मल वैल्यू को शून्य पर फ़्लश किया जा सकता है और वैल्यू को शून्य पर राउंड किया जा सकता है. इसकी तुलना में, rs_fp_full फ़ंक्शन में, सामान्य से कम वैल्यू को सही तरीके से मैनेज करना ज़रूरी है. जैसे, 1.17549435e-38f से कम वैल्यू. rs_fp_rull फ़ंक्शन के लिए, सबसे नज़दीकी संख्या पर राउंड करने की ज़रूरत होती है. साथ ही, बराबर होने पर उसे सम संख्या पर राउंड किया जाता है.

सामान्य गणित के फ़ंक्शन के वैरिएंट का इस्तेमाल करके, सटीक/तेज़ी से नतीजे पाने के लिए अलग-अलग विकल्प चुने जा सकते हैं. ऐसे फ़ंक्शन जिनका नाम

• native_: इसमें कस्टम हार्डवेयर लागू किए जा सकते हैं, लेकिन इनकी सटीक जानकारी नहीं मिलती. इसके अलावा, सबनॉर्मल वैल्यू को शून्य पर फ़्लश किया जा सकता है, शून्य के आस-पास की वैल्यू का इस्तेमाल किया जा सकता है, और NaN और अनंत इनपुट को सही तरीके से मैनेज नहीं किया जा सकता.
• half_: 16 बिट फ़्लोट का इस्तेमाल करके, अंदरूनी कैलकुलेशन कर सकता है. इसके अलावा, सब-नॉर्मल वैल्यू को शून्य पर फ़्लश किया जा सकता है और शून्य के आस-पास की वैल्यू का इस्तेमाल किया जा सकता है.

कॉन्स्टेंट
M_1_PI	1 / pi, 32-बिट फ़्लोट के तौर पर
M_2_PI	2 / pi, 32 बिट फ़्लोट के तौर पर
M_2_SQRTPI	2 / sqrt(pi), 32-बिट फ़्लोट के तौर पर
M_E	e को 32-बिट फ़्लोट के तौर पर
M_LN10	log_e(10), 32-बिट फ़्लोट के तौर पर
M_LN2	log_e(2), 32-बिट फ़्लोट के तौर पर
M_LOG10E	log_10(e), 32-बिट फ़्लोट के तौर पर
M_LOG2E	log_2(e), 32-बिट फ़्लोट के तौर पर
M_PI	pi, 32-बिट फ़्लोट के तौर पर
M_PI_2	pi / 2 को 32-बिट फ़्लोट के तौर पर
M_PI_4	pi / 4, 32 बिट फ़्लोट के तौर पर
M_SQRT1_2	1 / sqrt(2), 32 बिट फ़्लोट के तौर पर
M_SQRT2	sqrt(2), 32-बिट फ़्लोट के तौर पर

फ़ंक्शन
abs	किसी पूर्णांक की ऐब्सलूट वैल्यू
acos	इनवर्स कोसाइन
acosh	इनवर्स हाइपरबोलिक कोसाइन
acospi	इनवर्स कोसाइन को पाई से भाग दिया गया
asin	इनवर्स साइन
asinh	इनवर्स हाइपरबोलिक साइन
asinpi	इनवर्स साइन को पाई से भाग दिया गया
atan	इनवर्स टेंजेंट
atan2	किसी रेशियो का इनवर्स टेंजेंट
atan2pi	किसी अनुपात के इनवर्स टेंजेंट को पाई से भाग दिया जाता है
atanh	इनवर्स हाइपरबोलिक टेंजेंट
atanpi	इनवर्स टेंजेंट को पाई से भाग दिया गया
cbrt	घनमूल
ceil	सबसे छोटा पूर्णांक, किसी वैल्यू से कम नहीं होना चाहिए
clamp	किसी वैल्यू को किसी रेंज में सीमित करना
clz	शुरुआत में मौजूद 0 बिट की संख्या
copysign	किसी संख्या के साइन को दूसरी संख्या में कॉपी करता है
cos	कोसाइन
cosh	हाइपरबोलिक कोसाइन
cospi	किसी संख्या को पाई से गुणा करने पर मिलने वाली कोसाइन
डिग्री	रेडियन को डिग्री में बदलता है
erf	गणितीय एरर फ़ंक्शन
erfc	गणितीय कॉम्प्लीमेंट्री एरर फ़ंक्शन
exp	किसी संख्या के घात में e
exp10	10 की किसी संख्या के साथ घात लगाना
exp2	2 की किसी संख्या के घात का मान
expm1	किसी संख्या को ई की घात में रखकर, उसमें से एक घटाना
fabs	किसी फ़्लोट की ऐब्सलूट वैल्यू
fdim	दो वैल्यू के बीच का पॉज़िटिव अंतर
फ़्लोर	सबसे छोटा पूर्णांक, किसी वैल्यू से ज़्यादा नहीं होना चाहिए
fma	गुणा और जोड़ना
fmax	ज़्यादा से ज़्यादा दो फ़्लोट
fmin	कम से कम दो फ़्लोट
fmod	मॉड्यूलो
fract	फ़्रैक्शनल पार्ट का धनात्मक होना
frexp	बाइनरी मैन्टिसा और एक्सपोनेंट
half_recip	16 बिट तक सटीक वैल्यू के हिसाब से रिसिप्रोकल
half_rsqrt	वर्गमूल का व्युत्क्रम, जिसे 16 बिट तक सटीक तौर पर कैलकुलेट किया जाता है
half_sqrt	16 बिट तक सटीक तरीके से निकाला गया वर्गमूल
hypot	कर्ण
ilogb	दो के आधार पर घातांक
ldexp	मैन्टिसा और एक्सपोनेंट से फ़्लोटिंग पॉइंट बनाता है
lgamma	गामा फ़ंक्शन का नेचुरल लॉगारिद्म
लॉग	नेचुरल लॉगरिदम
log10	10 के आधार वाला लॉगारिदम
log1p	किसी वैल्यू के साथ 1 जोड़कर उसका नेचुरल लॉगारिद्म
log2	बेस 2 लॉगारिदम
logb	दो के आधार पर घातांक
mad	गुणा और जोड़ना
max	ज़्यादा से ज़्यादा
मिनट	कम से कम
मिक्स करें	दो वैल्यू को आपस में मिलाता है
modf	पूर्णांक और भिन्न वाले कॉम्पोनेंट
nan	यह कोई संख्या नहीं है
nan_half	यह कोई संख्या नहीं है
native_acos	अनुमानित इनवर्स कोसाइन
native_acosh	अनुमानित इनवर्स हाइपरबोलिक कोसाइन
native_acospi	अनुमानित इनवर्स कोसाइन को पाई से भाग दिया गया
native_asin	इनवर्स साइन का अनुमान
native_asinh	अनुमानित इनवर्स हाइपरबोलिक साइन
native_asinpi	इनवर्स साइन के अनुमानित मान को पाई से भाग दिया गया
native_atan	इनवर्स टेंजेंट का अनुमान
native_atan2	किसी अनुपात का अनुमानित इनवर्स टेंजेंट
native_atan2pi	किसी अनुपात के इनवर्स टेंजेंट का अनुमानित मान, जिसे पाई से भाग दिया गया है
native_atanh	इनवर्स हाइपरबोलिक टैंजेंट का अनुमान
native_atanpi	अनुमानित इनवर्स टेंजेंट को पाई से भाग दिया गया
native_cbrt	घनमूल का अनुमान
native_cos	अनुमानित कोसाइन
native_cosh	हाइपरबोलिक कोसाइन का अनुमान
native_cospi	किसी संख्या को पाई से गुणा करने पर, कोसाइन का अनुमानित मान
native_divide	अनुमानित डिवीज़न
native_exp	किसी संख्या के साथ e का अनुमानित घातांक
native_exp10	10 की घात को किसी संख्या के आस-पास का अनुमान लगाना
native_exp2	किसी संख्या के लिए, 2 की घात का अनुमानित मान
native_expm1	किसी संख्या को एक से कम घात में, e के आस-पास का अनुमान
native_hypot	कर्ण (हाइपोटेन्यूज़) का अनुमान
native_log	नैचुरल लॉगरिदम का अनुमान
native_log10	10 के आधार वाला अनुमानित लॉगारिद्म
native_log1p	किसी वैल्यू के साथ 1 जोड़कर, उसका अनुमानित नेचुरल लॉगारिद्म
native_log2	बेस 2 लॉगारिद्म का अनुमान
native_powr	अनुमानित पॉज़िटिव बेस को घात में बढ़ाया गया
native_recip	अनुमानित रिसिप्रोकल
native_rootn	nवें मूल का अनुमान लगाना
native_rsqrt	वर्गमूल का अनुमानित व्युत्क्रम
native_sin	साइन फ़ंक्शन का अनुमानित वैल्यू
native_sincos	साइन और कोसाइन का अनुमान लगाना
native_sinh	हाइपरबोलिक साइन का अनुमान
native_sinpi	किसी संख्या को पाई से गुणा करने पर, उसका अनुमानित साइन
native_sqrt	अनुमानित वर्गमूल
native_tan	टेंगेंट का अनुमान
native_tanh	हाइपरबोलिक टैंजेंट का अनुमान
native_tanpi	किसी संख्या को पाई से गुणा करने पर, उसका अनुमानित टैंजेंट
nextafter	अगला फ़्लोटिंग पॉइंट नंबर
pow	आधार को घात में बढ़ाना
pown	बेस को पूर्णांक घातांक पर बढ़ाया गया
powr	किसी घात में बढ़ाया गया पॉज़िटिव आधार
रेडियन	डिग्री को रेडियन में बदलता है
बचे हुए	भागफल में बचे हुए अंक
remquo	भागफल और शेष
rint	राउंड ऑफ़ करना
rootn	एनवां रूट
round	शून्य से दूर राउंड करना
rsRand	स्यूडो-रैंडम नंबर
rsqrt	वर्गमूल का व्युत्क्रम
sign	वैल्यू का साइन
पाप	साइन
sincos	साइन और कोसाइन
sinh	हाइपरबोलिक साइन
sinpi	किसी संख्या को पाई से गुणा करने पर मिलने वाला साइन
sqrt	वर्गमूल
step	अगर वैल्यू किसी वैल्यू से कम है, तो 0, अन्यथा 0
tan	टेंगेंट
tanh	हाइपरबोलिक टेंगेंट
tanpi	किसी संख्या को पाई से गुणा करने पर, उसका टेंगेंट
tgamma	गामा फ़ंक्शन
trunc	फ़्लोटिंग पॉइंट को छोटा करता है

वेक्टर मैथ फ़ंक्शन

ये फ़ंक्शन, इनपुट आर्ग्युमेंट को n-डाइमेंशनल स्पेस में वैक्टर के तौर पर दिखाते हैं.

32 बिट फ़्लोट पर किए जाने वाले गणितीय ऑपरेशन के सटीक होने पर, pragmas rs_fp_relaxed और rs_fp_full का असर पड़ता है. ज़्यादा जानकारी के लिए, गणितीय स्थिरांक और फ़ंक्शन लेख पढ़ें.

सामान्य गणित के फ़ंक्शन के वैरिएंट का इस्तेमाल करके, सटीक/तेज़ी से नतीजे पाने के लिए अलग-अलग विकल्प चुने जा सकते हैं. ऐसे फ़ंक्शन जिनका नाम

• native_: इसमें कस्टम हार्डवेयर लागू किए जा सकते हैं, लेकिन इनकी सटीक जानकारी नहीं मिलती. इसके अलावा, सबनॉर्मल वैल्यू को शून्य पर फ़्लश किया जा सकता है, शून्य के आस-पास की वैल्यू का इस्तेमाल किया जा सकता है, और NaN और अनंत इनपुट को सही तरीके से मैनेज नहीं किया जा सकता.
• fast_: 16 बिट फ़्लोट का इस्तेमाल करके, अंदरूनी कैलकुलेशन कर सकता है. इसके अलावा, सब-नॉर्मल वैल्यू को शून्य पर फ़्लश किया जा सकता है और शून्य के आस-पास की वैल्यू का इस्तेमाल किया जा सकता है.

फ़ंक्शन
क्रॉस	दो वेक्टर का क्रॉस प्रॉडक्ट
distance	दो बिंदुओं के बीच की दूरी
बिंदु	दो वैक्टर का डॉट प्रॉडक्ट
fast_distance	दो बिंदुओं के बीच की अनुमानित दूरी
fast_length	वेक्टर की अनुमानित लंबाई
fast_normalize	नॉर्मलाइज़ किया गया अनुमानित वेक्टर
लंबाई	वेक्टर की लंबाई
native_distance	दो बिंदुओं के बीच की अनुमानित दूरी
native_length	वेक्टर की अनुमानित लंबाई
native_normalize	किसी वेक्टर को करीब-करीब सामान्य करना
normalize	वेक्टर को सामान्य करना

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

इन फ़ंक्शन की मदद से, 2x2, 3x3, और 4x4 रैंक वाले स्क्वेयर मैट्रिक्स में बदलाव किया जा सकता है. ये खास तौर पर ग्राफ़िक ट्रांसफ़ॉर्मेशन के लिए काम के होते हैं और ये OpenGL के साथ काम करते हैं.

हम पंक्तियों और कॉलम के लिए, शून्य पर आधारित इंडेक्स का इस्तेमाल करते हैं. उदाहरण के लिए, rs_matrix4x4 का आखिरी एलिमेंट (3, 3) पर मिलता है.

RenderScript, कॉलम-मेजर मैट्रिक्स और कॉलम-आधारित वैक्टर का इस्तेमाल करता है. किसी वेक्टर को बदलने के लिए, वेक्टर के बाद में गुणा किया जाता है. जैसे, (matrix * vector), जैसा कि rsMatrixMultiply() में दिया गया है.

एक साथ दो ट्रांसफ़ॉर्मेशन करने वाली ट्रांसफ़ॉर्मेशन मैट्रिक बनाने के लिए, दो सोर्स मैट्रिक को गुणा करें. पहला ट्रांसफ़ॉर्मेशन, दाईं ओर दिए गए आर्ग्युमेंट के तौर पर इस्तेमाल करें. उदाहरण के लिए, ऐसा ट्रांसफ़ॉर्मेशन मैट्रिक बनाने के लिए जो ट्रांसफ़ॉर्मेशन s1 के बाद s2 लागू करता है, rsMatrixLoadMultiply(&combined, &s2, &s1) को कॉल करें. यह s2 * (s1 * v) से लिया गया है, जो (s2 * s1) * v है.

ट्रांसफ़ॉर्मेशन मैट्रिक बनाने के लिए, हमारे पास दो तरह के फ़ंक्शन हैं: rsMatrixLoadTransformation और rsMatrixTransformation. पहले स्टाइल में, ट्रांसफ़ॉर्मेशन मैट्रिक को पहले आर्ग्युमेंट में ही सेव किया जाता है. बाद वाला, पहले से मौजूद ट्रांसफ़ॉर्मेशन मैट्रिक में बदलाव करता है, ताकि नया ट्रांसफ़ॉर्मेशन पहले हो सके. उदाहरण के लिए, अगर किसी ऐसे मैट्रिक पर rsMatrixTranslate() को कॉल किया जाता है जो पहले से ही स्केलिंग करता है, तो वेक्टर पर लागू होने पर, नतीजा देने वाला मैट्रिक पहले ट्रांसलेशन करेगा और फिर स्केलिंग करेगा.

फ़ंक्शन
rsExtractFrustumPlanes	फ़्रस्टम प्लेन का हिसाब लगाना
rsIsSphereInFrustum	यह जांचता है कि कोई गोला, फ़्रस्टम प्लेन के अंदर है या नहीं
rsMatrixGet	एक एलिमेंट पाना
rsMatrixInverse	मैट्रिक्स को बदले बिना उसका इन्वर्स बनाता है
rsMatrixInverseTranspose	मैट्रिक्स को इनवर्स और ट्रांसपोज़ करता है
rsMatrixLoad	कोई मैट्रिक लोड करना या कॉपी करना
rsMatrixLoadFrustum	फ़्रस्टम प्रोजेक्शन मैट्रिक्स लोड करना
rsMatrixLoadIdentity	आइडेंटिटी मैट्रिक लोड करना
rsMatrixLoadMultiply	दो मैट्रिक्स को गुणा करना
rsMatrixLoadOrtho	ऑर्थोग्राफ़िक प्रोजेक्शन मैट्रिक्स लोड करना
rsMatrixLoadPerspective	पर्सपेक्टिव प्रोजेक्शन मैट्रिक लोड करना
rsMatrixLoadRotate	रोटेशन मैट्रिक्स लोड करना
rsMatrixLoadScale	स्केलिंग मैट्रिक लोड करना
rsMatrixLoadTranslate	अनुवाद मैट्रिक्स लोड करना
rsMatrixMultiply	किसी मैट्रिक्स को वेक्टर या किसी अन्य मैट्रिक्स से गुणा करना
rsMatrixRotate	ट्रांसफ़ॉर्मेशन मैट्रिक्स पर रोटेशन लागू करना
rsMatrixScale	ट्रांसफ़ॉर्मेशन मैट्रिक में स्केलिंग लागू करना
rsMatrixSet	एक एलिमेंट सेट करना
rsMatrixTranslate	ट्रांसफ़ॉर्मेशन मैट्रिक्स पर ट्रांसलेशन लागू करना
rsMatrixTranspose	मैट्रिक्स की जगह को ट्रांसपोज़ करना

क्वार्टरनियन फ़ंक्शन

ये फ़ंक्शन, क्वार्टरनियन में बदलाव करते हैं.

फ़ंक्शन
rsQuaternionAdd	दो क्वार्टरनियन जोड़ना
rsQuaternionConjugate	क्वार्टरनियन का कॉन्जुगेट
rsQuaternionDot	दो क्वार्टरनियन का डॉट प्रॉडक्ट
rsQuaternionGetMatrixUnit	क्वार्टरनियन से रोटेशन मैट्रिक्स पाना
rsQuaternionLoadRotate	रोटेशन क्वार्टरनियन बनाना
rsQuaternionLoadRotateUnit	क्वार्टरनियन, जो किसी भी यूनिट वेक्टर के बारे में रोटेशन दिखाता है
rsQuaternionMultiply	किसी क्वार्टरनियन को स्केलर या किसी दूसरे क्वार्टरनियन से गुणा करना
rsQuaternionNormalize	क्वाटरनियन को सामान्य बनाना
rsQuaternionSet	क्वार्टरनियन बनाना
rsQuaternionSlerp	दो क्वार्टरनियन के बीच गोलाकार लीनियर इंटरपोलेशन

ऐटॉमिक अपडेट फ़ंक्शन

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

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

ध्यान दें कि RenderScript में, आपका कोड अलग-अलग थ्रेड में चल सकता है. भले ही, आपने उन्हें साफ़ तौर पर न बनाया हो. RenderScript के रनटाइम में, अक्सर एक कोर को कई थ्रेड में बांटकर चलाया जाता है. ग्लोबल वैल्यू को अपडेट करने के लिए, एटॉमिक फ़ंक्शन का इस्तेमाल करना चाहिए. अगर हो सके, तो इनसे पूरी तरह से बचने के लिए अपने एल्गोरिदम में बदलाव करें.

फ़ंक्शन
rsAtomicAdd	थ्रेड-सेफ़ जोड़ना
rsAtomicAnd	थ्रेड-सेफ़ बिटवाइज़ ऐंड
rsAtomicCas	थ्रेड-सेफ़ तुलना और सेट
rsAtomicDec	थ्रेड-सेफ़ घटाना
rsAtomicInc	थ्रेड-सेफ़ इंक्रीमेंट
rsAtomicMax	थ्रेड-सेफ़ मैक्सिमम
rsAtomicMin	थ्रेड-सेफ़ मिनिमम
rsAtomicOr	थ्रेड-सेफ़ बिटवाइज़ या
rsAtomicSub	थ्रेड-सेफ़ घटाना
rsAtomicXor	थ्रेड-सेफ़ बिटवाइज़ एक्सक्लूज़िव या

समय से जुड़े फ़ंक्शन और टाइप

नीचे दिए गए फ़ंक्शन का इस्तेमाल, घड़ी का मौजूदा समय और सिस्टम के चालू रहने का मौजूदा समय बताने के लिए किया जा सकता है. हमारा सुझाव है कि इन फ़ंक्शन को कर्नेल में न कॉल करें.

प्रकार
rs_time_t	1 जनवरी, 1970 से सेकंड
rs_tm	तारीख और समय का स्ट्रक्चर

फ़ंक्शन
rsGetDt	पिछले कॉल के बाद से बीत चुका समय
rsLocaltime	स्थानीय समय में बदलना
rsTime	1 जनवरी, 1970 से सेकंड
rsUptimeMillis	सिस्टम के चालू रहने का कुल समय (मिलीसेकंड में)
rsUptimeNanos	सिस्टम के अपटाइम की जानकारी नैनोसेकंड में

ऐलोकेशन बनाने के फ़ंक्शन

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

इन फ़ंक्शन को सीधे तौर पर या किसी दूसरे तरीके से, कॉल किए जा सकने वाले फ़ंक्शन से कॉल किया जा सकता है. अगर किसी कंट्रोल-फ़्लो पाथ की वजह से, RenderScript के किसी कोर फ़ंक्शन से इन फ़ंक्शन को कॉल किया जा सकता है, तो कंपाइलर गड़बड़ी जनरेट करेगा.

फ़ंक्शन
rsCreateAllocation	दिए गए टाइप का rs_allocation ऑब्जेक्ट बनाएं.
rsCreateElement	तय किए गए डेटा टाइप का rs_element ऑब्जेक्ट बनाता है
rsCreatePixelElement	तय किए गए डेटा टाइप और डेटा टाइप के rs_element ऑब्जेक्ट बनाता है
rsCreateType	तय किए गए एलिमेंट और शेप एट्रिब्यूट के साथ rs_type ऑब्जेक्ट बनाता है
rsCreateVectorElement	तय किए गए डेटा टाइप और वेक्टर की चौड़ाई का rs_element ऑब्जेक्ट बनाता है

ऐलोकेशन डेटा ऐक्सेस फ़ंक्शन

नीचे दिए गए फ़ंक्शन का इस्तेमाल, उन सेल को पाने और सेट करने के लिए किया जा सकता है जिनमें ऐलोकेशन शामिल है.

• अलग-अलग सेल को ऐक्सेस करने के लिए, rsGetElementAt* और rsSetElementAt फ़ंक्शन का इस्तेमाल किया जाता है.
• rsAllocationCopy* और rsAllocationV* फ़ंक्शन का इस्तेमाल करके, एक से ज़्यादा सेल कॉपी की जा सकती हैं.
• सैंपलर की मदद से वैल्यू पाने के लिए, rsSample का इस्तेमाल करें.

rsGetElementAt और rsSetElement* फ़ंक्शन के नामों में कुछ गड़बड़ी है. ये एलिमेंट नहीं पाते या सेट नहीं करते, जो डेटा टाइप के जैसे होते हैं. ये सेल पाते या सेट करते हैं. इन्हें rsGetCellAt और rsSetCellAt के तौर पर देखें.

फ़ंक्शन
rsAllocationCopy1DRange	एक-दूसरे के बाद वाली सेल को, अलग-अलग ऐलोकेशन के बीच कॉपी करना
rsAllocationCopy2DRange	ऐलोकेशन के बीच सेल का आयताकार क्षेत्र कॉपी करना
rsAllocationVLoadX	स्केलर के ऐलोकेशन से सदिश पाना
rsAllocationVStoreX	स्केलर के ऐलोकेशन में वेक्टर को स्टोर करना
rsGetElementAt	किसी ऐलोकेशन से सेल दिखाना
rsGetElementAtYuv_uchar_U	YUVs के ऐलोकेशन का U कॉम्पोनेंट पाना
rsGetElementAtYuv_uchar_V	YUVs के ऐलोकेशन का V कॉम्पोनेंट पाना
rsGetElementAtYuv_uchar_Y	YUV के ऐलोकेशन का Y कॉम्पोनेंट पाना
rsSample	टेक्सचर ऐलोकेशन से वैल्यू का सैंपल लेना
rsSetElementAt	किसी ऐलोकेशन की सेल सेट करना

ऑब्जेक्ट की विशेषताओं के फ़ंक्शन

नीचे दिए गए फ़ंक्शन का इस्तेमाल, किसी ऐलोकेशन, एलिमेंट या सैंपलर ऑब्जेक्ट की विशेषताओं के बारे में क्वेरी करने के लिए किया जा सकता है. ये ऑब्जेक्ट, Java से बनाए जाते हैं. इन्हें स्क्रिप्ट से नहीं बनाया जा सकता.

ऐलोकेशन:

रेंडरस्क्रिप्ट कर्नेल में डेटा भेजने और पाने के लिए, ऐलोकेशन का इस्तेमाल मुख्य तौर पर किया जाता है.

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

सेल के इस कलेक्शन में कई डाइमेंशन (X, Y, Z, Array0, Array1, Array2, Array3), फ़ेस (क्यूबमैप के लिए) और ज़्यादा जानकारी (मिपमैपिंग के लिए) हो सकती है.

ऐलोकेशन बनाने के बारे में जानने के लिए, android.renderscript.Allocation देखें.

एलिमेंट:

RenderScript में "एलिमेंट" शब्द का इस्तेमाल थोड़ा अस्पष्ट तरीके से किया जाता है. ऐसा इसलिए है, क्योंकि यह एलोकेशन की सेल के लिए और उस टाइप के इंस्टैंशिएशन, दोनों के लिए जानकारी देता है. उदाहरण के लिए:

• rs_element, टाइप की खास जानकारी का हैंडल है, और
• rsGetElementAt() जैसे फ़ंक्शन में, "एलिमेंट" का मतलब टाइप का इंस्टैंशिएशन होता है, यानी कि किसी ऐलोकेशन की सेल.

नीचे दिए गए फ़ंक्शन की मदद से, टाइप स्पेसिफ़िकेशन की विशेषताओं के बारे में क्वेरी की जा सकती है.

एलिमेंट में, C में पाए जाने वाले डेटा टाइप की जानकारी दी जा सकती है. जैसे, कोई पूर्णांक, फ़्लोट या बूलियन. यह किसी RenderScript ऑब्जेक्ट के हैंडल की जानकारी भी दे सकता है. बुनियादी टाइप की सूची के लिए, rs_data_type देखें.

एलिमेंट, बुनियादी टाइप के तय साइज़ वाले वेक्टर (साइज़ 2, 3 या 4) के वर्शन तय कर सकते हैं. एलिमेंट को एक साथ ग्रुप करके, जटिल एलिमेंट बनाए जा सकते हैं. इससे C स्ट्रक्चर की डेफ़िनिशन बनती हैं.

एलिमेंट में एक तरह की जानकारी भी हो सकती है. यह जानकारी, पिक्सल डेटा को समझने के लिए इस्तेमाल की जाती है. rs_data_kind देखें.

सामान्य एलिमेंट के लिए ऐलोकेशन बनाते समय, F32_2 जैसे पहले से तय किए गए कई एलिमेंट में से किसी एक का इस्तेमाल किया जा सकता है.

जटिल एलिमेंट बनाने के लिए, Element.Builder Java क्लास का इस्तेमाल करें.

सैंपलर:

सैंपलर ऑब्जेक्ट से यह तय होता है कि किसी कर्नेल में, एलोकेशन को स्ट्रक्चर के तौर पर कैसे पढ़ा जा सकता है. android.renderscript.S देखें.

फ़ंक्शन
rsAllocationGetDimFaces	एक से ज़्यादा चेहरे दिखना
rsAllocationGetDimLOD	जानकारी के लेवल
rsAllocationGetDimX	X डाइमेंशन का साइज़
rsAllocationGetDimY	Y डाइमेंशन का साइज़
rsAllocationGetDimZ	Z डाइमेंशन का साइज़
rsAllocationGetElement	वह ऑब्जेक्ट पाएं जो किसी ऐलोकेशन की सेल के बारे में बताता है
rsClearObject	किसी ऑब्जेक्ट को रिलीज़ करना
rsElementGetBytesSize	किसी एलिमेंट का साइज़
rsElementGetDataKind	एलिमेंट का टाइप
rsElementGetDataType	किसी एलिमेंट का डेटा टाइप
rsElementGetSubElement	किसी कॉम्प्लेक्स एलिमेंट का सब-एलिमेंट
rsElementGetSubElementArraySize	किसी कॉम्प्लेक्स एलिमेंट के सब-एलिमेंट का कलेक्शन साइज़
rsElementGetSubElementCount	सब-एलिमेंट की संख्या
rsElementGetSubElementName	सब-एलिमेंट का नाम
rsElementGetSubElementNameLength	सब-एलिमेंट के नाम की लंबाई
rsElementGetSubElementOffsetBytes	इंस्टैंशिएट किए गए सब-एलिमेंट का ऑफ़सेट
rsElementGetVectorSize	एलिमेंट का वेक्टर साइज़
rsIsObject	खाते का हैंडल खाली है या नहीं
rsSamplerGetAnisotropy	सैंपलर की एनिसोट्रॉपी
rsSamplerGetMagnification	सैंपलर की ज़ूम की वैल्यू
rsSamplerGetMinification	सैंपलर की छोटी की गई वैल्यू
rsSamplerGetWrapS	सैंपलर रैप S वैल्यू
rsSamplerGetWrapT	सैंपलर रैप T वैल्यू

कर्नेल को कॉल करने के फ़ंक्शन और टाइप

rsForEach() फ़ंक्शन का इस्तेमाल, किसी स्क्रिप्ट के रूट कर्नेल को चालू करने के लिए किया जा सकता है.

अन्य फ़ंक्शन का इस्तेमाल, डाइमेंशन और मौजूदा इंडेक्स जैसे, किसी चल रहे कर्नेल के कॉल के बारे में जानकारी पाने के लिए किया जाता है. ये फ़ंक्शन, आर्ग्युमेंट के तौर पर rs_kernel_context लेते हैं.

प्रकार
rs_for_each_strategy_t	सेल को प्रोसेस करने का सुझाया गया क्रम
rs_kernel	कर्नेल फ़ंक्शन का हैंडल
rs_kernel_context	kernel invocation context का हैंडल
rs_script_call_t	सेल के अलग-अलग वर्शन की जानकारी

फ़ंक्शन
rsForEach	कर्नेल लॉन्च करता है
rsForEachInternal	(इंटरनल एपीआई) स्लॉट नंबर के साथ, मौजूदा स्क्रिप्ट में कोई कर्नेल लॉन्च करें
rsForEachWithOptions	विकल्पों के साथ एक कर्नेल लॉन्च करता है
rsGetArray0	दिए गए कर्नेल कॉन्टेक्स्ट के लिए, Array0 डाइमेंशन में इंडेक्स
rsGetArray1	तय किए गए कर्नेल कॉन्टेक्स्ट के लिए, Array1 डाइमेंशन में इंडेक्स
rsGetArray2	दिए गए कर्नेल कॉन्टेक्स्ट के लिए, Array2 डाइमेंशन में इंडेक्स
rsGetArray3	तय किए गए कर्नेल कॉन्टेक्स्ट के लिए, Array3 डाइमेंशन में इंडेक्स
rsGetDimArray0	दिए गए कर्नेल कॉन्टेक्स्ट के लिए, Array0 डाइमेंशन का साइज़
rsGetDimArray1	दिए गए कर्नेल कॉन्टेक्स्ट के लिए, Array1 डाइमेंशन का साइज़
rsGetDimArray2	दिए गए कर्नेल कॉन्टेक्स्ट के लिए, Array2 डाइमेंशन का साइज़
rsGetDimArray3	दिए गए कर्नेल कॉन्टेक्स्ट के लिए, Array3 डाइमेंशन का साइज़
rsGetDimHasFaces	बताए गए कर्नेल कॉन्टेक्स्ट के लिए एक से ज़्यादा चेहरे मौजूद हैं
rsGetDimLod	बताए गए कर्नेल कॉन्टेक्स्ट के लिए, जानकारी के लेवल की संख्या
rsGetDimX	दिए गए कर्नेल कॉन्टेक्स्ट के लिए X डाइमेंशन का साइज़
rsGetDimY	दिए गए कर्नेल कॉन्टेक्स्ट के लिए Y डाइमेंशन का साइज़
rsGetDimZ	दिए गए कर्नेल कॉन्टेक्स्ट के लिए Z डाइमेंशन का साइज़
rsGetFace	दिए गए कर्नेल कॉन्टेक्स्ट के लिए, चेहरे का कोऑर्डिनेट
rsGetLod	तय किए गए कर्नेल कॉन्टेक्स्ट के लिए, ज़्यादा जानकारी वाले लेवल के डाइमेंशन में इंडेक्स

इनपुट/आउटपुट फ़ंक्शन

इन फ़ंक्शन का इस्तेमाल इन कामों के लिए किया जाता है:

• Java क्लाइंट को जानकारी भेजें, और
• प्रोसेस किया गया ऐलोकेशन भेजें या प्रोसेस करने के लिए अगला ऐलोकेशन पाएं.

फ़ंक्शन
rsAllocationIoReceive	सूची में नया कॉन्टेंट पाना
rsAllocationIoSend	सूची में नया कॉन्टेंट भेजना
rsSendToClient	क्लाइंट को मैसेज भेजना, बिना ब्लॉक किए
rsSendToClientBlocking	क्लाइंट को मैसेज भेजना, ब्लॉक करना

डीबग करने के फ़ंक्शन

नीचे दिए गए फ़ंक्शन, ऐप्लिकेशन डेवलपमेंट के दौरान इस्तेमाल किए जाने के लिए हैं. इनका इस्तेमाल शिपिंग के लिए नहीं किया जाना चाहिए.

फ़ंक्शन
rsDebug	मैसेज और वैल्यू को लॉग करना

ग्राफ़िक्स फ़ंक्शन और टाइप

RenderScript का ग्राफ़िक्स सबसिस्टम, एपीआई लेवल 23 में हटा दिया गया था.