OpenGL ES 3.0 पर SSAO

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

मैं इस आशय के बारे में विवरणों में नहीं जाऊंगा, यह माना जाता है कि पाठक अन्य स्रोतों ( विकि या चरण 3 ) से प्रभाव के बारे में जान सकते हैं। लेख में जोर मोबाइल प्लेटफॉर्म के अनुकूलन पर है, लेकिन "एसएसएओ की किस्मों" अनुभाग में एक संक्षिप्त समीक्षा की जाएगी।

SSAO प्रदर्शन के मामले में काफी लज्जाजनक प्रभाव है और एक ही समय में औसत उपयोगकर्ता के लिए काफी अदृश्य है, इसलिए मैंने अभी भी इसे मोबाइल डिवाइस पर नहीं देखा है। इसके अलावा, इसे तेज करने के लिए MRT सपोर्ट की जरूरत होती है, जो केवल OpenGL ES वर्जन 3.0 में दिखाई दिया।

विभिन्न प्रकार के एस.एस.ए.ओ.

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

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

सबसे सरल कार्यान्वयन में, एक गहराई बफर छायांकन की गणना करने के लिए पर्याप्त है - इसलिए प्रश्न में पिक्सेल के जेड-समन्वय की तुलना नमूने से पिक्सेल के जेड-निर्देशांक के साथ की जाती है, इस अंतर के आधार पर और छायांकन पर विचार किया जाता है।

हालांकि, ऊपर की तस्वीर को देखें - यह दर्शाता है कि बिंदु के नीचे की सतह भी छायांकन में अपना ("बेकार") योगदान देती है। नतीजतन, चित्र ग्रे टन में प्राप्त किया जाता है, अर्थात्, जहां कोई छायांकन नहीं होना चाहिए - यह है। यह कुछ इस तरह दिखता है:


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

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

इस मामले में, नमूना से प्रत्येक बिंदु के लिए मानदंडों को पढ़ना आवश्यक नहीं है, क्योंकि उनमें से सभी पहले से ही स्थित हैं जैसा कि यह होना चाहिए, यह प्रश्न में बिंदु को सामान्य करने के लिए पर्याप्त है।

मेरी राय में यह सबसे अच्छा संशोधन है, और यह लागू है।

कार्यान्वयन

सबसे पहले, हमें मानदंडों, गहराई और रंग के भंडारण के लिए बफर की आवश्यकता है। यह OpenGL ES 3.0 की तकनीक का उपयोग करता है - एकाधिक रेंडर लक्ष्य, हम कई बफ़र्स बनाते हैं, और फिर उसी समय उन्हें लिखते हैं। कोड में, यह इस तरह दिखता है (मैंने एक अलग फ़ंक्शन के रूप में बनावट निर्माण):

// ,        (  ),     GLenum buffers[] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1}; GLuint fbo; GLuint colorBuff; GLuint normBuff; GLuint depthBuff; //     void createTexture(GLuint &id, int inFormat, int w, int h, int format, int type, int filter, int wrap, void* pix=NULL) { glGenTextures(1, &id); glBindTexture(GL_TEXTURE_2D, id); glTexImage2D(GL_TEXTURE_2D, 0, inFormat, w, h, 0, format, type, pix); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap); } ... glGenFramebuffers(1, &fbo); //   glBindFramebuffer(GL_FRAMEBUFFER, fbo); // width  height -   createTexture(colorBuff, GL_RGB8, width, height, GL_RGB, GL_UNSIGNED_BYTE, GL_NEAREST, GL_MIRRORED_REPEAT); createTexture(normBuff, GL_RGB8, width, height, GL_RGB, GL_UNSIGNED_BYTE, GL_NEAREST, GL_MIRRORED_REPEAT); createTexture(depthBuff, GL_DEPTH_COMPONENT24, width, height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, GL_NEAREST, GL_MIRRORED_REPEAT); //    ,        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorBuff, 0); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, normBuff, 0); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthBuff, 0); int err = glCheckFramebufferStatus(GL_FRAMEBUFFER); if (err != GL_FRAMEBUFFER_COMPLETE) LOGE("Main framebuffer error: %i", err); glDrawBuffers(2, buffers); 

आगे भी इसी तरह से, लेकिन एक बनावट के साथ, आपको SSAO के तहत एक बफर बनाने की आवश्यकता है।

यह बफर छोटा हो सकता है, लेकिन अब इसे स्क्रीन रिज़ॉल्यूशन (मेरे मामले में, 1920x1080) के समान बना दें।

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

दृश्य को हमेशा की तरह प्रस्तुत किया जाता है, एकमात्र अंतर यह है कि रंग के अलावा, हम मानदंडों को भी रिकॉर्ड करते हैं और गहराई बफर को थोड़ा बदलते हैं। दृश्य प्रतिपादन के लिए वर्टेक्स शेडर:

 #version 300 es uniform mat4 matrixProj; uniform mat4 matrixView; uniform vec3 lightPos; layout(location = 0) in vec3 vPos; //   layout(location = 1) in vec3 nPos; //  layout(location = 2) in vec3 tPos; //     layout(location = 3) in vec2 tCoord; //   out vec3 light; out vec3 gNorm; out float zPos; out vec2 texCoord; void main() { vec4 p = matrixProj*matrixView*vec4(vPos, 1.0); gl_Position = p; texCoord = tCoord; //      ,           vec3 bitangent = cross(tPos, nPos); mat3 tbn = mat3(tPos, bitangent, nPos); light = normalize(lightPos-vPos)*tbn; zPos = pz; //  z-  -      vec4 n = (matrixView*vec4(nPos, 0.0)); //      gNorm = normalize(n.xyz); } 

टुकड़े टुकड़े करना:

 #version 300 es precision highp float; //      24- ,     ,     24 ,       uniform sampler2D texDiff; //   uniform sampler2D texNorm; //       layout(location = 0) out vec3 colorBuff; //    layout(location = 1) out vec3 normBuff; //   in vec3 light; in vec3 gNorm; in float zPos; in vec2 texCoord; const vec3 ambientColor = vec3(0.3); const float zFar = 40.0; //    void main() { vec3 n = normalize(texture(texNorm, texCoord).xyz*2.0-1.0); vec3 l = normalize(light); vec3 c = texture(texDiff, texCoord).rgb; float a = clamp(dot(n, l), 0.0, 1.0); colorBuff = c*(a+ambientColor); //   normBuff = normalize(gNorm)*0.5+0.5; //   gl_FragDepth = zPos/zFar; //       } 

हमें गोलार्ध (वास्तविक चयन) में यादृच्छिक बिंदुओं की एक सरणी की भी आवश्यकता है। छायांकन के लिए सुंदर (ताकि बोलने के लिए, और अधिक शारीरिक) - गोलार्ध में बिंदुओं का घनत्व केंद्र से अधिक और सीमा से कम होना चाहिए। यानी सामान्य वितरण कानून होना।

 for (int i=0; i<samples; i++) { rndTable[i] = vec3(random(-1, 1), random(-1, 1), random(-1, -0)); //    ( ) rndTable[i].normalize(); //   rndTable[i] *= (i+1.0f)/samples; //  ( ) } 

बेशक, नमूने में अंकों की संख्या इतनी बड़ी नहीं होगी। चलो इसे 10 के बराबर बनाते हैं।

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

Shader में, यह इस तरह दिखेगा:

 vec3 normal = texture(normBuff, texCoord).xyz*2.0-1.0; vec3 rvec = texture(randMap, texCoord*scr).xyz*2.0-1.0; vec3 tangent = normalize(rvec-normal*dot(rvec, normal)); vec3 bitangent = cross(tangent, normal); mat3 rotate = mat3(tangent, bitangent, normal); 

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

 #version 300 es const fov = 0.57735; layout(location = 0) in vec2 vPos; layout(location = 1) in vec2 tCoord; uniform float aspect; out vec2 texCoord; out vec3 viewRay; void main() { gl_Position = vec4(vPos, 0.0, 1.0); texCoord = tCoord; viewRay = vec3(-vPos.x*aspect*fov, -vPos.y*fov, 1.0); //   ,      } 

पिक्सेल शेडर में, किरण के आधार पर बिंदु की स्थिति इस प्रकार से बहाल की जाती है:

 float depth = texture(depthBuff, texCoord).x; //    ,   depth *= zFar; //  z- vec3 pos = viewRay*depth; //      

रोटेशन मैट्रिक्स और बिंदु की स्थिति प्राप्त करने के बाद, हम नमूनों से छायांकन मूल्य प्राप्त करने के लिए आगे बढ़ सकते हैं:

 float acc = 0.0; for (int i=0; i<samples; i++) { vec3 samplePos = rotate*rndTable[i]; //  samplePos = samplePos*radius+pos; //        //          ,            vec4 shift = proj*vec4(samplePos, 1.0); shift.xy /= shift.w; shift.xy = shift.xy*0.5+0.5; //   z- float sampleDepth = texture(depthBuff, shift.xy).x*zFar; //       -      .     ,       ,   smoothstep,   -   float distanceCheck = smoothstep(0.0, 1.0, radius/abs(pos.z-sampleDepth)); //       -     .  - ,    step acc += step(sampleDepth, samplePos.z)*distanceCheck; } 

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

आप परिणाम देख सकते हैं:

ऊपरी बाएं कोने में संख्या प्रति सेकंड फ़्रेम की संख्या को दर्शाती है। बहुत कुछ नहीं। इसके अलावा, सतह पर धारियों पर ध्यान दें। बात यह है कि गहराई बफर का प्रतिनिधित्व करने में, सतह पूरी तरह से चिकनी नहीं है। वहां सब कुछ पूरी तरह से असतत है, और कोई भी सतह सीढ़ी की तरह दिखती है, इसलिए नमूनों में से कुछ बिंदु इन चरणों के अंदर दिखाई देते हैं:

इसलिए, नमूना बनाते समय, शून्य जेड-समन्वय से शुरू नहीं करना बेहतर होता है, लेकिन कुछ छोटे मूल्य से, उदाहरण के लिए, 0.1 से। इस मामले में, गोलार्ध नीचे से छंटनी की तरह है:

और फिर नमूने से अंक "चरणों" में नहीं गिरेंगे। तस्वीर बेहतर होगी:

लेकिन एफपीएस अभी भी अधिक नहीं है।

अनुकूलन

स्पष्ट और सबसे आम समाधान नमूना में अंकों की संख्या को कम करना और एसएसएओ बफर के आकार को कम करना है। बफर आकार को आधा करके, हम लगभग 150% एफपीएस वृद्धि प्राप्त करते हैं। हालांकि, बफर के आकार को बदलते हुए, हम वस्तुओं की सीमाओं पर कलाकृतियों को प्राप्त करते हैं, इसलिए हम इसे बहुत कम नहीं करेंगे।

एल्गोरिथ्म के परिणाम को देखें - यह देखा जा सकता है कि अधिकांश छवि सफेद है और इसमें कोई छायांकन नहीं है। लेकिन एल्गोरिथ्म प्रत्येक पिक्सेल के लिए पूरा करता है। कुछ प्रकार का मुखौटा बनाना अच्छा होगा, जो अनावश्यक टुकड़ों को काट सकता है।
यह मुखौटा छोटे बफर के लिए SSAO की गणना करके प्राप्त किया जा सकता है। यही है, हम SSAO के लिए बफर की तुलना में चौड़ाई और ऊंचाई में 16 गुना छोटे और दूसरा बफर बनाएँगे। नमूनों की संख्या को पांच तक कम करें और उन्हें यादृच्छिक न बनाएं, लेकिन गोलार्ध के केंद्र से समान दूरी पर स्थित हैं:

 for (int i=0; i<samplesLow; i++) { float angle = DEG2RAD*360.0f*i/samplesLow; rndTableLow[i] = vec3(sinf(angle), cosf(angle), -0.1); } 

चूंकि हमें छाया के बिना चिकनी बदलाव के एक मुखौटा की आवश्यकता होती है, इसलिए हम परिणाम को बहुत विपरीत बना देंगे - पिक्सेल या तो काला या सफेद है:

 outColor = step(254.0/255.0, 1.0-(acc/float(samples))); 

ब्लर शैडर को भी सरलीकृत किया जाता है, अब यह दो टुकड़े करने वाले शेड नहीं होंगे, लेकिन एक वर्ग के कोनों पर स्थित चार नमूनों के साथ होगा:

 #version 300 es precision mediump float; uniform sampler2D ssaoLowBuff; uniform float aspect; layout(location = 0) out float outColor; in vec2 texCoord; const float blurSize = 0.01; void main() { float sum = 0.0; sum += texture(ssaoLowBuff, vec2(texCoord.x - blurSize, texCoord.y - blurSize*aspect)).r; sum += texture(ssaoLowBuff, vec2(texCoord.x - blurSize, texCoord.y + blurSize*aspect)).r; sum += texture(ssaoLowBuff, vec2(texCoord.x, texCoord.y )).r; sum += texture(ssaoLowBuff, vec2(texCoord.x + blurSize, texCoord.y - blurSize*aspect)).r; sum += texture(ssaoLowBuff, vec2(texCoord.x + blurSize, texCoord.y + blurSize*aspect)).r; outColor = step(254.0/255.0, sum/5.0); } 

हमें यह मास्क मिलता है:

इसका उपयोग करते हुए, हम SSAO की गणना करते हैं (मैंने बफर का आकार 1.5 गुना घटाया, और नमूनों की संख्या घटाकर 8 कर दी):

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

 #version 300 es precision highp float; //  24-   const int samples = 8; //   const float radius = 0.5; //   const float power = 2.0; //   const float zFar = 40.0; //    uniform sampler2D normBuff; //   uniform sampler2D depthBuff; //   uniform sampler2D randMap; //      uniform sampler2D ssaoMask; //  SSAO -  uniform vec2 scr; //    randMap,     SSAO uniform vec3 rndTable[samples]; //  uniform mat4 proj; //   layout(location = 0) out float outColor; //   in vec2 texCoord; //   in vec3 viewRay; //    void main() { //      ,    -   float k = texture(ssaoMask, texCoord).x; if (k==1.0) discard; //          -  float depth = texture(depthBuff, texCoord).x; if (depth==1.0) discard; depth *= zFar; vec3 pos = viewRay*depth; vec3 normal = texture(normBuff, texCoord).xyz*2.0-1.0; vec3 rvec = texture(randMap, texCoord*scr).xyz*2.0-1.0; vec3 tangent = normalize(rvec-normal*dot(rvec, normal)); vec3 bitangent = cross(tangent, normal); mat3 rotate = mat3(tangent, bitangent, normal); float acc = 0.0; for (int i=0; i<samples; i++) { vec3 samplePos = rotate*rndTable[i]; //  samplePos = samplePos*radius+pos; //        //          ,            vec4 shift = proj*vec4(samplePos, 1.0); shift.xy /= shift.w; shift.xy = shift.xy*0.5+0.5; //   z- float sampleDepth = texture(depthBuff, shift.xy).x*zFar; //       -      .     ,       ,   smoothstep,   -   float distanceCheck = smoothstep(0.0, 1.0, radius/abs(pos.z-sampleDepth)); //       -     .  - ,    step acc += step(sampleDepth, samplePos.z)*distanceCheck; } outColor = pow(1.0-(acc/float(samples)), power); //   } 

प्रदर्शन के साथ वीडियो (SSAO का आकार स्क्रीन से 2 गुना छोटा है):

(SSAO का आकार स्क्रीन से 1.5 गुना छोटा है):

ब्योरा

इस प्रक्रिया में, मैं कुछ दिलचस्प चीजों के बारे में आया, लेकिन चूंकि यह थोड़ा अपमानजनक है, इसलिए मैंने इसे बिगाड़ने के तहत छिपा दिया।

डेमो

यदि OpenGL ES 3.0 के साथ Android पर कोई डिवाइस है, तो आप एप्लिकेशन को चलाने का प्रयास कर सकते हैं। मैंने GUI पर समय बर्बाद न करने का निर्णय लिया, इसलिए कोई विशेष सेटिंग्स नहीं हैं, और नियंत्रण स्क्रीन पर सशर्त क्षेत्रों द्वारा किया जाता है:

1. ऊपर / नीचे स्लाइड करें - ज़ूम इन / ज़ूम आउट करें
2. आउटपुट बफर (ssao, कम ssao, ssao + रंग, रंग केवल) बदलें
3. पर / बंद कलंक
4. दृश्य का परिवर्तन

मुफ्त स्क्रीन क्षेत्र - कैमरा रोटेशन


मेरे द्वारा निर्धारित पैरामीटर हैं:

• नमूनों की संख्या = 8।
• ssao और ब्लर बफ़र्स का आकार स्क्रीन रिज़ॉल्यूशन से डेढ़ गुना छोटा है।
• कम ssao = 5 के लिए नमूनों की संख्या।
• कम ssao बफर का आकार स्क्रीन रिज़ॉल्यूशन से 16 गुना छोटा है।

स्रोत कोड - अपने को पथ बदलने के लिए मत भूलना
apk - नोट 3 n9000 (mali T62), नोट 3 n9005 (एड्रेनो 330), नेक्सस 5 (एड्रेनो 330), एचटीसी वन (एड्रेनो 320) पर परीक्षण किया गया।

संदर्भ

इस परियोजना में काम आने वाले विभिन्न संदर्भ:
स्क्रीन-स्पेस एंबिएंस इंप्लीमेंट ऑन स्टेप 3 डी। SSAO बनाने के कई तरीके
OpenGL ES 3.0 एपीआई संदर्भ कार्ड - OpenGL ES 3.0 का एक त्वरित संदर्भ हेमिस्फोरिकल
स्क्रीन-स्पेस एम्बिएंट इंक्लूजन - हेमिस्फोरिकल SSAO
स्टोन ब्रिज 3 डी मॉडल को लागू करने के तरीकों में से एक - पुल मॉडल जिसे मैंने
जॉन-चैपमैन-ग्राफिक्स डेमो में उपयोग किया है : SSAO ट्यूटोरियल - मेरे लिए हेमिसफेरिकल
SSAO SSAO का सबसे अच्छा कार्यान्वयन देखें गेम
बफ़र का गहराई से आक्रमण करना -
गेम डेवलपर्स के लिए z- बफर रैखिक बीजगणित के विभिन्न अभ्यावेदन,
अपने SSAO कलाकृतियों को जानें - SSAO की कलाकृतियाँ / जाम / अशुद्धि और उन्हें खत्म करने के तरीके