OpenGL ES 3 पर वीएसडीसीटी

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

कार्यान्वयन

मैं मूल ओमनी-दिशात्मक छाया मानचित्रण एल्गोरिथ्म पर ध्यान केंद्रित नहीं करूंगा, लिंक में आप संबंधित संसाधनों को पढ़ सकते हैं। हम 6 रैखिक अनुमानों का उपयोग करेंगे और तुरंत वीएसडीसीटी के कार्यान्वयन के लिए आगे बढ़ेंगे।

आइए जानें कि हम क्या करना चाहते हैं। 6 छाया मानचित्र प्राप्त करना आवश्यक है जो रोशनी के एक बिंदु स्रोत से दिखाई देने वाली सभी दिशाओं को कवर करेंगे। यानी प्रत्येक दिशाओं के लिए एक मानचित्र each X, ± Y, the Z। ताकि कार्ड के बीच कोई अंतराल न हो, हम प्रत्येक अनुमान के लिए FOV को 90 डिग्री पर सेट करेंगे:



6 मॉडल-व्यू मैट्रिस इस तरह से निर्मित होते हैं (पी - प्रकाश स्रोत के निर्देशांक):

Math::ViewMatrix( vec3( 0.0f, 0.0f, 1.0f ), vec3( 0.0f, 1.0f, 0.0f ), vec3( -1.0f, 0.0f, 0.0f ), P ); Math::ViewMatrix( vec3( 0.0f, 0.0f, -1.0f ), vec3( 0.0f, 1.0f, 0.0f ), vec3( 1.0f, 0.0f, 0.0f ), P ); Math::ViewMatrix( vec3( 1.0f, 0.0f, 0.0f ), vec3( 0.0f, 0.0f, 1.0f ), vec3( 0.0f, -1.0f, 0.0f ), P ); Math::ViewMatrix( vec3( 1.0f, 0.0f, 0.0f ), vec3( 0.0f, 0.0f, -1.0f ), vec3( 0.0f, 1.0f, 0.0f ), P ); Math::ViewMatrix( vec3( -1.0f, 0.0f, 0.0f ), vec3( 0.0f, 1.0f, 0.0f ), vec3( 0.0f, 0.0f, -1.0f ), P ); Math::ViewMatrix( vec3( 1.0f, 0.0f, 0.0f ), vec3( 0.0f, 1.0f, 0.0f ), vec3( 0.0f, 0.0f, 1.0f ), P ); LMatrix4 ViewMatrix( const LVector3& X, const LVector3& Y, const LVector3& Z, const LVector3& Position ) { LMatrix4 Matrix; Matrix[0][0] = Xx; Matrix[1][0] = Xy; Matrix[2][0] = Xz; Matrix[3][0] = -X.Dot( Position ); Matrix[0][1] = Yx; Matrix[1][1] = Yy; Matrix[2][1] = Yz; Matrix[3][1] = -Y.Dot( Position ); Matrix[0][2] = Zx; Matrix[1][2] = Zy; Matrix[2][2] = Zz; Matrix[3][2] = -Z.Dot( Position ); Matrix[0][3] = 0.0f; Matrix[1][3] = 0.0f; Matrix[2][3] = 0.0f; Matrix[3][3] = 1.0f; return Matrix; } 

सभी अनुमान समान हैं, 1: 1 के पहलू और 90 डिग्री के कोण के साथ वादा करते हैं:

 float NearCP = 0.5f; float FarCP = 512.0f; Math::Perspective( 90.0f, 1.0f, NearCP, FarCP ); 

6 छाया मानचित्रों में से प्रत्येक का प्रतिपादन करते समय, हम प्रकाश स्रोत से वर्तमान पिक्सेल तक की दूरी को बचाते हैं और इसे 8-बिट RGBA प्रारूप में पैक करते हैं।

 void main() { float D = distance( v_WorldPosition, u_LightPosition.xyz ); out_FragColor = Pack( D / 512.0 ); } vec4 Pack(float Value) { const vec4 BitSh = vec4( 256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0); const vec4 BitMsk = vec4( 0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0 ); vec4 Comp = fract( Value * BitSh ); Comp -= Comp.xxyz * BitMsk; return Comp; } 

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

  LRectDivider( int Size, int NumSubRects ) : FSize( Size ) , FNumSubRects( NumSubRects ) , FCurrentX( 0 ) , FCurrentY( 0 ) { float Sqrt = sqrt( float( FNumSubRects ) ); FNumSlotsWidth = ( int )ceil( Sqrt ); FNumSlotsHeight = ( int )Sqrt; FSlotWidth = FSize / FNumSlotsWidth; FSlotHeight = FSize / FNumSlotsHeight; } void GetNextRect( int* X, int* Y, int* W, int* H ) { if ( X ) { *X = FCurrentX * FSlotWidth; } if ( Y ) { *Y = FCurrentY * FSlotHeight; } if ( W ) { *W = FSlotWidth; } if ( H ) { *H = FSlotHeight; } NextRect(); } private: void NextRect() { if ( ++FCurrentX >= FNumSlotsWidth ) { FCurrentX = 0; FCurrentY++; } } 

लगभग (लगभग, क्योंकि वास्तव में हमने 32-बिट फ्लोट की दूरी को अल्फा सहित 4 चैनलों में पैक किया है), इस दृश्य के एटलस इस तरह दिखाई देंगे:



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

प्रमुख अक्ष दिशा	लक्ष्य	अनुसूचित जाति	Tc	मा
+ आरएक्स	POSITIVE_X	-Rz	-Ry	आरएक्स
-Rx	NEGATIVE_X	Rz	-Ry	आरएक्स
+ Ry	POSITIVE_Y	आरएक्स	Rz	ry
-Ry	NEGATIVE_Y	आरएक्स	-Rz	ry
+ Rz	POSITIVE_Z	आरएक्स	-Ry	Rz
-Rz	NEGATIVE_Z	-Rx	-Ry	Rz

हम इन योगों में प्राप्त Sc, Tc और Ma को प्रतिस्थापित करते हैं और 2D निर्देशांक s, t प्राप्त करते हैं:

 s = 0.5 * ( Sc / abs(Ma) + 1 ) t = 0.5 * ( Tc / abs(Ma) + 1 ) 

यहाँ GLSL shader कोड है जो बनावट के सभी परिवर्तनों का समन्वय करता है और परिणामस्वरूप s और t को एटलस में धकेलता है:

 vec2 GetShadowTC( vec3 Dir ) { float Sc; float Tc; float Ma; float FaceIndex; float rx = Dir.x; float ry = Dir.y; float rz = Dir.z; vec3 adir = abs(Dir); Ma = max( max( adir.x, adir.y ), adir.z ); if ( adir.x > adir.y && adir.x > adir.z ) { Sc = ( rx > 0.0 ) ? rz : -rz; Tc = ry; FaceIndex = ( rx > 0.0 ) ? 0.0 : 1.0; } else if ( adir.y > adir.x && adir.y > adir.z ) { Sc = rx; Tc = ( ry > 0.0 ) ? rz : -rz; FaceIndex = ( ry > 0.0 ) ? 2.0 : 3.0; } else { Sc = ( rz > 0.0 ) ? -rx : rx; Tc = ry; FaceIndex = ( rz > 0.0 ) ? 4.0 : 5.0; } float s = 0.5 * ( Sc / Ma + 1.0 ); float t = 0.5 * ( Tc / Ma + 1.0 ); //    s = s / 3.0; t = t / 2.0; float Flr = floor(FaceIndex / 3.0); float Rmd = FaceIndex - (3.0 * Flr); s += Rmd / 3.0; t += Flr / 2.0; return vec2( s, t ); } 

दृश्य में ही छाया को खींचना अत्यंत सरल है:

 float ComputePointLightShadow() { vec3 LightDirection = v_WorldPosition - u_LightPosition.xyz; vec2 IndirectTC = GetShadowTC( normalize( LightDirection ) ); vec4 Light = texture( Texture7, IndirectTC ); float LightD = Unpack( Light ) * 512.0; if ( LightD < length( LightDirection ) + u_ShadowDepthBias ) return u_ShadowIntensity; return 1.0; } float Unpack(vec4 Value) { const vec4 BitShifts = vec4( 1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0 ); return dot( Value, BitShifts ); } 

वह सब है!

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

डेमो

यदि आपके पास OpenGL ES 3.0 और Android 4.4 वाला Android उपकरण है, तो आप एप्लिकेशन चलाने का प्रयास कर सकते हैं: play.google.com/store/apps/details?id=com.linderdaum.engine.vsdct

संदर्भ

लिंडरडैम इंजन
ShaderX3: DirectX और OpenGL के साथ उन्नत प्रतिपादन
सर्वदिशात्मक छाया मानचित्रण के लिए वीएसडीसीटी
ओम्निडायरेक्शनल शैडो और वीएसडीसीटी ऑन ओपन ES 3
ओमनी-दिशात्मक छाया मानचित्रण