हम AGAL पर एक shader लिखते हैं

यह कोई रहस्य नहीं है कि फ्लैश प्लेयर 11 में ग्राफिक्स त्वरण के लिए जीपीयू समर्थन है। नया संस्करण मोलेहिल एपीआई का परिचय देता है, जिससे आप वीडियो कार्ड के साथ काफी निचले स्तर पर काम कर सकते हैं, जो एक तरफ कल्पना को पूरा खेल देता है, और दूसरी ओर आधुनिक 3 डी ग्राफिक्स के सिद्धांतों की गहरी समझ की आवश्यकता होती है।

यह लेख शेडर्स - AGAL (एडोब ग्राफिक्स असेंबली लैंग्वेज) लिखने की भाषा पर केंद्रित होगा। यह माना जाता है कि पाठक आधुनिक रीयलटाइम 3 डी ग्राफिक्स के मूल सिद्धांतों से परिचित है, और आदर्श रूप से ओपनजीएल या डायरेक्ट 3 डी के साथ अनुभव है। बाकी के लिए, मैं एक छोटा भ्रमण करूंगा:

• प्रत्येक फ्रेम में सब कुछ फिर से प्रस्तुत किया गया है, स्क्रीन को आंशिक रूप से फिर से परिभाषित करने के दृष्टिकोण बेहद अवांछनीय हैं
• 2 डी - 3 डी का एक विशेष मामला
• वीडियो कार्ड त्रिभुज को रेखापुंज करने में सक्षम है और इसके अलावा कुछ भी नहीं है
• त्रिकोण शीर्ष पर बनाए गए हैं
• प्रत्येक शीर्ष में विशेषताएँ होती हैं (समन्वय, सामान्य, भार आदि)
• त्रिकोण में कोने को निर्दिष्ट करने का क्रम सूचकांकों द्वारा निर्धारित किया जाता है
• वर्टेक्स और इंडेक्स डेटा को क्रमशः वर्टेक्स और इंडेक्स बफ़र्स में संग्रहीत किया जाता है
• shader - एक वीडियो कार्ड द्वारा निष्पादित कार्यक्रम
• प्रत्येक शीर्ष एक शीर्ष छायादार से होकर गुजरता है, और प्रत्येक पिक्सेल जब एक टुकड़े (पिक्सेल) के माध्यम से रेखित होता है
• वीडियो कार्ड पूर्णांक के साथ काम करना नहीं जानता है, लेकिन यह 4D वैक्टर के साथ ठीक काम करता है

वाक्य-विन्यास

वर्तमान AGAL कार्यान्वयन शैडर मॉडल 2.0 फसल का उपयोग करता है, अर्थात। 2005 तक सीमित आयरन फेलिसिस्ट। लेकिन यह याद रखने योग्य है कि यह केवल shader प्रोग्राम की क्षमताओं की सीमा है, लेकिन हार्डवेयर प्रदर्शन की नहीं। यह संभव है कि फ्लैश प्लेयर के भविष्य के संस्करणों में बार को एसएम 3.0 में उठाया जाएगा, और हम एक बार में कई बनावटों को प्रस्तुत करने और वर्टेक्सर शेडर से सीधे बनावट का नमूना बनाने में सक्षम होंगे, लेकिन एडोब नीति को देखते हुए, यह मोबाइल उपकरणों की अगली पीढ़ी तक नहीं होगा।

कोई भी AGAL कार्यक्रम अनिवार्य रूप से एक निम्न-स्तरीय विधानसभा भाषा है। भाषा अपने आप में बहुत सरल है, लेकिन उचित देखभाल की आवश्यकता है। प्रपत्र के निर्देशों के एक समूह द्वारा shader कोड का प्रतिनिधित्व किया जाता है:

opcode [dst], [src1], [src2] 

जिसमें एक मुक्त व्याख्या का अर्थ है "मापदंडों को src1 और src2 के साथ opcode कमांड को निष्पादित करना, मान को dst पर लौटना"। एक shader में 256 निर्देश तक हो सकते हैं। रजिस्टरों के नाम dst, src1, और src2: va, vc, fc, vt, ft, op, oc, v, fs हैं। इनमें से प्रत्येक रजिस्टर, fs के अपवाद के साथ, एक चार-आयामी (xyzw या rgba) वेक्टर है। वेक्टर के व्यक्तिगत घटकों के साथ काम करने की संभावना है, जिसमें स्विज़लिंग (एक अलग क्रम) भी शामिल है:

 dp4 ft0.x, v0.xyzw, v0.yxww 

प्रत्येक प्रकार के रजिस्टरों पर अधिक विस्तार से विचार करें।

आउटपुट रजिस्टर

गणना के परिणामस्वरूप, वर्टेक्स शेडर को ऑप (आउटपुट स्थिति) रजिस्टर में वर्टेक्स की विंडो स्थिति का मान लिखना होगा, और टुकड़ा शेडर - इन ओशन (आउटपुट कलर) अंतिम पिक्सेल रंग का मूल्य। टुकड़ा shader के मामले में, किलो निर्देश द्वारा प्रसंस्करण को रद्द करना संभव है, जिसे नीचे वर्णित किया जाएगा।

मामले की विशेषता

एक शीर्ष पर 8 वेक्टर विशेषताएँ हो सकती हैं, जो वैडर रजिस्टरों के माध्यम से शेडर से एक्सेस की जाती हैं, जिनमें वर्टेक्स बफर की स्थिति Context3D.setVertexBufferAt फ़ंक्शन द्वारा निर्धारित की जाती है। विशेषता डेटा FLOAT_1, FLOAT_2, FLOAT_3, FLOAT_4 और BYTES_4 में हो सकते हैं। नाम में संख्या वेक्टर के घटकों की संख्या को इंगित करती है। यह ध्यान दिया जाना चाहिए कि BYTES_4 के मामले में, घटकों के मूल्यों को सामान्य किया जाता है, अर्थात। 255 से विभाजित।

इंटरपोलर को पंजीकृत करें

ऑप रजिस्टर में लिखने के अलावा, वर्टेक्स शेडर v रजिस्टरों के माध्यम से 8 वैक्टर तक के टुकड़े shader में स्थानांतरित कर सकता है। इन वैक्टरों के मूल्यों को रेखांकन के दौरान पूरे बहुभुज क्षेत्र में रैखिक रूप से प्रक्षेपित किया जाएगा। हम एक त्रिकोण के उदाहरण का उपयोग करते हुए प्रक्षेपकों के संचालन का वर्णन करते हैं, जिसके शीर्ष पर एक विशेषता प्रदर्शित होती है, जिसे टुकड़े टुकड़े करने वाले द्वारा प्रदर्शित किया जाता है:

 // vertex mov op, va0 //   -  mov v0, va1 //        // fragment mov oc, v0 //       

चर रजिस्टर करें

शीर्ष और मध्यवर्ती शेड में, 8 रजिस्टर vt और ft तक मध्यवर्ती गणना परिणाम संग्रहीत करने के लिए उपलब्ध हैं । उदाहरण के लिए, टुकड़ा shader में, शीर्ष कार्यक्रम (v0..v3 रजिस्टर) से प्राप्त चार वैक्टर की राशि की गणना करना आवश्यक है:

 add ft0, v0, v1 // ft0 = v0 + v1 add ft0, ft0, v2 // ft0 = ft0 + v2 add ft0, ft0, v3 // ft0 = ft0 + v3 

नतीजतन, ft0 हमारी ज़रूरत की राशि संग्रहीत करेगा, और सब कुछ बहुत अच्छा लग रहा है, लेकिन पहली नज़र में एक अनुकूलन संभावना है जो पहली नज़र में स्पष्ट नहीं है, जो सीधे वीडियो कार्ड सॉफ़्टवेयर पाइपलाइन की वास्तुकला से संबंधित है और आंशिक रूप से इसके उच्च प्रदर्शन का कारण है।

शेड्स ILP (निर्देश-स्तर समांतरवाद) की अवधारणा पर आधारित हैं, जो कि नाम से देखते हुए, आपको एक साथ कई निर्देशों को निष्पादित करने की अनुमति देता है। इस तंत्र को सक्रिय करने के लिए मुख्य शर्त एक दूसरे से निर्देशों की स्वतंत्रता है। जैसा कि ऊपर दिए गए उदाहरण पर लागू होता है:

 add ft0, v0, v1 // ft0 = v0 + v1 add ft1, v2, v3 // ft1 = v2 + v3 add ft0, ft0, ft1 // ft0 = ft0 + ft1 

पहले दो निर्देशों को एक साथ निष्पादित किया जाएगा, क्योंकि स्वतंत्र रजिस्टरों के साथ काम करें। इस से यह इस प्रकार है कि आपके shader के प्रदर्शन में महत्वपूर्ण भूमिका एक दूसरे से उनकी स्वतंत्रता के रूप में निर्देशों की संख्या से बहुत अधिक नहीं निभाई जाती है।

पंजीकरण पंजीकृत करें

संख्यात्मक कोड के सीधे shader कोड में भंडारण की अनुमति नहीं है, अर्थात्। ऑपरेशन के लिए आवश्यक सभी स्थिरांक को Context3D.drawTriangles पर कॉल करने से पहले शेडर में स्थानांतरित किया जाना चाहिए, और vc (128 वैक्टर) और fc (28 वैक्टर) रजिस्टर में उपलब्ध होगा। स्क्वायर ब्रैकेट का उपयोग करके इसके सूचकांक द्वारा रजिस्टर तक पहुंचना संभव है, जो कंकाल एनीमेशन या अनुक्रमण सामग्री को लागू करते समय बहुत सुविधाजनक है। यह याद रखना महत्वपूर्ण है कि छायादार स्थिरांक स्थापित करने का संचालन अपेक्षाकृत महंगा है और यदि संभव हो तो इसे टाला जाना चाहिए। उदाहरण के लिए, वर्तमान फ्रेम में परिवर्तन नहीं होने पर प्रत्येक वस्तु को रेंडर करने से पहले प्रक्षेपण मैट्रिक्स को शेडर में स्थानांतरित करने का कोई मतलब नहीं है।

रजिस्टर-नमूना

आप Context3D.setTextureAt फ़ंक्शन के साथ 8 टेक्स्ट तक अंश shader में स्थानांतरित कर सकते हैं, जो संबंधित fs रजिस्टरों के माध्यम से एक्सेस किए जाते हैं, जो विशेष रूप से टेक्स ऑपरेटर में उपयोग किए जाते हैं। आइए त्रिभुज के साथ उदाहरण को थोड़ा बदलते हैं, और शीर्ष की दूसरी विशेषता के रूप में हम बनावट निर्देशांक पास करते हैं, और टुकड़े टुकड़े में हम इन पहले से प्रक्षेपित निर्देशांक द्वारा बनावट का नमूना बनाते हैं:

 // vertex mov op, va0 //  mov v0, va1 //   -   // fragment tex oc, v0, fs0 <2d,linear> //    

ऑपरेटरों

फिलहाल (अक्टूबर 2011), AGAL निम्नलिखित ऑपरेटरों को लागू करता है:

  mov dst = src1 neg dst = -src1 abs dst = abs(src1) add dst = src1 + src2 sub dst = src1 – src2 mul dst = src1 * src2 div dst = src1 / src2 rcp dst = 1 / src1 min dst = min(src1, src2) max dst = max(src1, src2) sat dst = max(min(src1, 1), 0) frc dst = src1 – floor(src1) sqt dst = src1^0.5 rsq dst = 1 / (src1^0.5) pow dst = src1^src2 log dst = log2(src1) exp dst = 2^src1 nrm dst = normalize(src1) sin dst = sine(src1) cos dst = cosine(src1) slt dst = (src1 < src2) ? 1 : 0 sge dst = (src1 >= src2) ? 1 : 0 dp3   dst = src1.x*src2.x + src1.y*src2.y + src1.z*src2.z dp4       dst = src1.x*src2.x + src1.y*src2.y + src1.z*src2.z + src1.w*src2.w crs   dst.x = src1.y * src2.z – src1.z * src2.y dst.y = src1.z * src2.x – src1.x * src2.z dst.z = src1.x * src2.y – src1.y * src2.x m33     33 dst.x = dp3(src1, src2[0]) dst.y = dp3(src1, src2[1]) dst.z = dp3(src1, src2[2]) m34     34 dst.x = dp4(src1, src2[0]) dst.y = dp4(src1, src2[1]) dst.z = dp4(src1, src2[2]) m44     44 dst.x = dp4(src1, src2[0]) dst.y = dp4(src1, src2[1]) dst.z = dp4(src1, src2[2]) dst.w = dp4(src1, src2[3]) kil       ,   src1  ,     alpha-test,       . tex       dst     src1   src2    ,   , : tex ft0, v0, fs0 <2d,repeat,linear,miplinear>     :   2d, cube  nearest, linear  nomip, miplinear, mipnearest  clamp, repeat 

शेष संचालकों, जिनमें सशर्त जंप और लूप शामिल हैं, को फ्लैश प्लेयर के भविष्य के संस्करणों में लागू करने की योजना है। लेकिन इसका मतलब यह नहीं है कि अब आप सामान्य रूप से भी उपयोग नहीं कर सकते हैं, अगर इन कार्यों के लिए एसएलटी और एसजीई निर्देश काफी उपयुक्त हैं।

प्रभाव

हम मूल बातें से परिचित हो गए, अब लेख का सबसे दिलचस्प हिस्सा नए ज्ञान का व्यावहारिक अनुप्रयोग है। जैसा कि बहुत शुरुआत में कहा गया है, एक shader लिखने की क्षमता ग्राफिक्स प्रोग्रामर के हाथों को पूरी तरह से खोल देती है, अर्थात। वास्तविक सीमाएँ केवल डेवलपर की कल्पना और गणितीय प्रेमी में होती हैं। पहले यह सत्यापित करना संभव था कि असेंबलर भाषा स्वयं सरल है, लेकिन सरलता के पीछे "चखने" की जटिलता को भूल गए कोड में निहित है। इसलिए, यदि आवश्यक हो तो इसे जल्दी से नेविगेट करने के लिए, मैं shader कोड के प्रमुख क्षेत्रों पर टिप्पणी करने की सलाह देता हूं।

फौजों को घर देना

बाद के सभी उदाहरणों के लिए शुरुआती बिंदु चायदानी के रूप में एक छोटा "रिक्त" होगा। एक त्रिकोण के साथ उदाहरण के विपरीत, हमें ऑब्जेक्ट के आसपास परिप्रेक्ष्य और रोटेशन के प्रभाव को बनाने के लिए कैमरे के प्रक्षेपण और परिवर्तन की मैट्रिक्स की आवश्यकता होती है। हम इसे निरंतर रजिस्टरों में पारित करेंगे। यह याद रखना महत्वपूर्ण है कि एक 4x4 मैट्रिक्स वास्तव में 4 रजिस्टरों पर कब्जा कर लेता है, और जब इसे vc0 रजिस्टर में लिखा जाता है, तो v0..v3 पर कब्जा कर लिया जाएगा। इसके अलावा, अक्सर शेडर (0.0, 0.5, 1.0, 2.0) में उपयोग की जाने वाली संख्याओं से एक निरंतर वेक्टर हमारे लिए उपयोगी है।
कुल मिलाकर, मूल shader कोड इस तरह दिखाई देगा:

 // vertex m44 op, va0, vc0 //  viewProj  // fragment mov ft0, fc0.xxxz //   ft0    mov oc, ft0 //  ft0     

बनावट मानचित्रण

लगभग एक असीमित संख्या में नमूनों के साथ, एक शेडर में 8 बनावट तक ओवरले संभव है। इसका मतलब यह है कि यह सीमा वास्तव में मायने नहीं रखती है जब एटलस या क्यूबिक बनावट का उपयोग किया जाता है। हम अपने उदाहरण में सुधार करेंगे और टुकड़े टुकड़े करने वाले में रंग निर्दिष्ट करने के बजाय, हम इसे बनावट से प्राप्त करेंगे निर्देशांक-इंटरपोलर, जो वर्टेक्स शेडर से अपनाए गए हैं:

 // vertex ... mov v0, va1 //       // fragment tex ft0, v0, fs0 <2d,repeat,linear,miplinear> 

लैम्बर्ट शेडिंग

सबसे आदिम प्रकाश मॉडल जो वास्तविक अनुकरण करता है। यह इस स्थिति पर आधारित है कि सतह पर प्रकाश की तीव्रता रेखीय रूप से घटती है, यह घटना वैक्टर और सामान्य से सतह के बीच के कोण के कोसाइन पर निर्भर करती है। गणित के स्कूल के पाठ्यक्रम से, हमें याद है कि यूनिट वैक्टर का स्केलर उत्पाद उन दोनों के बीच के कोण का कोसाइन देता है, इसलिए, रोशनी के हमारे लैंबर्ट फार्म का रूप होगा:
लैंबर्ट = डिफ्यूज़ * (एम्बिएंट + मैक्स (0, डॉट (लाइटवेक, नॉर्मल)))
रंग = लैंबर्ट
जहाँ डिफ्यूज़ बिंदु पर वस्तु का रंग है (उदाहरण के लिए बनावट से लिया गया है),
परिवेश - पृष्ठभूमि का रंग
लाइटवेक - एक बिंदु से एक प्रकाश स्रोत तक एक इकाई वेक्टर
सामान्य - सतह के लंबवत
रंग - पिक्सेल का अंतिम रंग

शेडर दो नए निरंतर पैरामीटर लेगा: स्रोत की स्थिति और पृष्ठभूमि प्रकाश का मूल्य:

 // vertex ... mov v1, va2 // v1 = normal sub v2, vc4, va0 // v2 = lightPos - vertex (lightVec) // fragment ... nrm ft1.xyz, v1 // normal ft1 = normalize(lerp_normal) nrm ft2.xyz, v2 // lightVec ft2 = normalize(lerp_lightVec) dp3 ft5.x, ft1.xyz, ft2.xyz // ft5 = dot(normal, lightVec) max ft5.x, ft5.x, fc0.x // ft5 = max(ft5, 0.0) add ft5, fc1, ft5.x // ft5 = ambient + ft5 mul ft0, ft0, ft5 // color *= ft5 

फोंग छायांकन

एक प्रकाश स्रोत से चमक की अवधारणा को लैम्बर्ट प्रकाश मॉडल में पेश करता है। इसका तात्पर्य है कि भड़कने की तीव्रता वेक्टर से स्रोत के बीच के कोण के कोस के अनुसार एक शक्ति-विधि कार्य द्वारा निर्धारित की जाती है और सतह के सापेक्ष प्रेक्षक के सदिश के प्रतिबिंब के परिणामस्वरूप दिशा होती है।
फोंग = पॉव ( अधिकतम (0, डॉट (लाइटवेक, रिफ्लेक्ट-व्यूवेक, नॉर्मल))), स्पेक्युलरपावर) * स्पेक्युलरवेल
रंग = लंबर + फोंग
जहां ViewVec दर्शकों की टकटकी वेक्टर है
SpecularPower - भड़कना के आकार का निर्धारण करने वाली डिग्री
SpecularLevel - तीव्रता स्तर या रंग भड़कना
प्रतिबिंबित - प्रतिबिंब गणना फ़ंक्शन f (v, n) = 2 * n * डॉट (n, v) - v

जटिल मॉडल के लिए, यह स्पेक्युलर और ग्लोस मैप्स का उपयोग करने के लिए प्रथागत है, जो रंग / तीव्रता (स्पेसुलर लाइवेल), साथ ही मॉडल के बनावट स्थान के अलग-अलग हिस्सों में स्पेक्युलर आकार (स्पेसुलरपावर) का निर्धारण करता है। हमारे मामले में, हम डिग्री और तीव्रता के निरंतर मूल्यों के साथ प्रबंधन करेंगे। हम व्यूअर शेक्स के नए पैरामीटर को पास करेंगे - ViewVec की बाद की गणना के लिए पर्यवेक्षक की स्थिति:

 // vertex ... sub v3, va0, vc5 // v3 = vertex - viewPos (viewVec) // fragment ... nrm ft3.xyz, v3 // viewVec ft3 = normalize(lerp_viewVec) //    reflect(-viewVec, normal) dp3 ft4.x, ft1.xyz ft3.xyz // ft4 = dot(normal, viewVec) mul ft4, ft1.xyz, ft4.x // ft4 *= normal add ft4, ft4, ft4 // ft4 *= 2 sub ft4, ft3.xyz, ft4 // reflect ft4 = viewVec - ft4 // phong dp3 ft6.x, ft2.xyz, ft4.xyz // ft6 = dot(lightVec, reflect) max ft6.x, ft6.x, fc0.x // ft6 = max(ft6, 0.0) pow ft6.x, ft6.x, fc2.w // ft6 = pow(ft6, specularPower) mul ft6, ft6.x, fc2.xyz // ft6 *= specularLevel add ft0, ft0, ft6 // color += ft6 

सामान्य मानचित्रण

एक सामान्य बनावट का उपयोग करके एक सतह स्थलाकृति का अनुकरण करने के लिए एक अपेक्षाकृत सरल विधि। इस तरह की बनावट में सामान्य की दिशा आमतौर पर आरजीबी मानों के रूप में सेट की जाती है, जो अपने निर्देशांक को सीमा 0..1 (xyz * 0.5 + 0.5) से कम करती है। नॉर्मल को ऑब्जेक्ट स्पेस (ऑब्जेक्ट स्पेस), और सापेक्ष स्थान (टैंगेंट स्पेस) में दोनों का प्रतिनिधित्व किया जा सकता है, जो बनावट निर्देशांक और सामान्य से लेकर शिखर तक के आधार पर बनाया गया है। पहले में कई बार टेबिलिंग और मिरर-टेक्सचरिंग की असंभवता के कारण बनावट के लिए बड़ी मेमोरी खपत के रूप में कई महत्वपूर्ण कमियां हैं, लेकिन यह आपको निर्देशों की संख्या को बचाने की अनुमति देता है। उदाहरण में, हम स्पर्शरेखा स्थान के साथ अधिक लचीले और सामान्य संस्करण का उपयोग करेंगे, जिसके लिए, सामान्य के अलावा, दो और अतिरिक्त बेस वैक्टर Tangent और Binormal की आवश्यकता है। कार्यान्वयन टीबीएन (स्पर्शरेखा, असामान्य, सामान्य) आधार पर viewVec और lightVec वैक्टर का अनुवाद करने के लिए उबलता है, और फिर टुकड़े टुकड़े में बनावट से सापेक्ष सामान्य प्राप्त करता है।

 // vertex ... // transform lightVec sub vt1, vc4, va0 // vt1 = lightPos - vertex (lightVec) dp3 vt3.x, vt1, va4 dp3 vt3.y, vt1, va3 dp3 vt3.z, vt1, va2 mov v2, vt3.xyzx // v2 = lightVec // transform viewVec sub vt2, va0, vc5 // vt2 = vertex - viewPos (viewVec) dp3 vt4.x, vt2, va4 dp3 vt4.y, vt2, va3 dp3 vt4.z, vt2, va2 mov v3, vt4.xyzx // v3 = viewVec // fragment tex ft1, v0, fs1 <2d,repeat,linear,miplinear> // ft1 = normalMap(v0) // 0..1 to -1..1 add ft1, ft1, ft1 // ft1 *= 2 sub ft1, ft1, fc0.z // ft1 -= 1 nrm ft1.xyz, ft1 // normal ft1 = normalize(normal) ... 

तून छायांकन

एक प्रकार का गैर-फोटोरिलेस्टिक प्रकाश मॉडल जो छायांकन के कार्टून ड्राइंग का अनुकरण करता है। यह विभिन्न तरीकों से लागू किया जाता है, जिनमें से सबसे सरल है लैम्बर्ट मॉडल से कोण के कोसाइन द्वारा 1 डी बनावट से एक रंग का चयन करना। हमारे मामले में, उदाहरण के लिए, एक 16x1 बनावट का उपयोग करें:

 // fragment ... dp3 ft5.x, ft1.xyz, ft2.xyz // ft5 = dot(normal, lightVec) tex ft0, ft5.xx, fs3 <2d,nearest> // color = toonMap(ft5) 

स्फीयर मैपिंग

प्रतिबिंब को अनुकरण करने का सबसे आसान विकल्प, अक्सर धातु के क्रोम चढ़ाना के प्रभाव के लिए उपयोग किया जाता है। एक पर्यावरण के रूप में एक फिशे की तरह गोलाकार विरूपण के साथ एक पर्यावरण का प्रतिनिधित्व करता है, जैसा कि नीचे दिखाया गया है:

मुख्य कार्य प्रतिबिंब वेक्टर के निर्देशांक को इसी बनावट निर्देशांक में बदलना है:
uv = (xy / sqrt (x ^ 2 + y ^ 2 + (z + 1) ^ 2)) * 0.5 + 0.5
बनावट के निर्देशांक 0..1 के सामान्यीकृत परिणाम को लाने के लिए गुणा और 0.5 की शिफ्ट की आवश्यकता होती है। एक आदर्श रूप से परावर्तक सतह के लिए सरल मामले में, मानचित्र का प्रभाव एडिटिव होता है, और अधिक जटिल मामलों के लिए जब एक फैलाना घटक की आवश्यकता होती है, तो यह फ्रेसेल फॉर्मूला के सन्निकटन का उपयोग करने के लिए प्रथागत है। जटिल मॉडलों के लिए भी, प्रतिबिंब मानचित्रों का अक्सर उपयोग किया जाता है, जो मॉडल की बनावट के विभिन्न भागों के प्रतिबिंब की तीव्रता को दर्शाता है।

 // fragment ... add ft6, ft4, fc0.xxz // ft6 = reflect (x, y, z + 1) dp3 ft6.x, ft6, ft6 // ft6 = ft6^2 rsq ft6.x, ft6.x // ft6 = 1 / sqrt(ft6) mul ft6, ft4, ft6.x // ft6 = reflect / ft6 mul ft6, ft6, fc0.y // ft6 *= 0.5 add ft6, ft6, fc0.y // ft6 += 0.5 tex ft0, ft6, fs2 <2d,nearest> // color = reflect(ft6) 

शायद यही अंत है। यहां प्रस्तुत उदाहरण, अधिकांश भाग के लिए, ऑब्जेक्ट की सामग्री के गुणों का वर्णन करते हैं, लेकिन शेड्स अन्य अनुप्रयोगों, जैसे कि कंकाल एनीमेशन, छाया, पानी, और अन्य अपेक्षाकृत जटिल कार्यों (गैर-दृश्य सहित) में उनके आवेदन का पता लगाते हैं। और कौशल के उचित पंप के साथ, वे आपको थोड़े समय में टाइप करके काफी जटिल चीजों को लागू करने की अनुमति देते हैं:

निष्कर्ष

फ़्लैश खेल - यह आसान है! लेख के लिए एक उदाहरण ।