வடிவியலை கட்டவிழ்த்தல்: WebGL-இன் மெஷ் ஷேடர் டாஸ்க் ஆம்ப்ளிஃபிகேஷன் பைப்லைனின் ஒரு ஆழமான பார்வை

இணையம் இனி ஒரு நிலையான, இரு பரிமாண ஊடகம் அல்ல. இது மூச்சுத்திணற வைக்கும் தயாரிப்பு உள்ளமைவுகள் மற்றும் கட்டடக்கலை காட்சிகள் முதல் சிக்கலான தரவு மாதிரிகள் மற்றும் முழுமையான விளையாட்டுகள் வரை, செழுமையான, அதிவேக 3D அனுபவங்களுக்கான ஒரு துடிப்பான தளமாக உருவாகியுள்ளது. இந்த பரிணாம வளர்ச்சி, கிராபிக்ஸ் செயலாக்க அலகு (GPU) மீது முன்னெப்போதும் இல்லாத கோரிக்கைகளை வைக்கிறது. பல ஆண்டுகளாக, நிலையான நிகழ்நேர கிராபிக்ஸ் பைப்லைன், சக்தி வாய்ந்ததாக இருந்தாலும், அதன் வயதைக் காட்டியுள்ளது, இது நவீன பயன்பாடுகளுக்குத் தேவையான வடிவியல் சிக்கலான தன்மைக்கு ஒரு தடையாக அடிக்கடி செயல்படுகிறது.

மெஷ் ஷேடர் பைப்லைன் இங்கே நுழைகிறது, இது WEBGL_mesh_shader நீட்டிப்பு வழியாக இப்போது இணையத்தில் அணுகக்கூடிய ஒரு முன்னுதாரணத்தை மாற்றும் அம்சமாகும். இந்த புதிய மாதிரி, GPU-இல் நாம் வடிவியலை எப்படி சிந்திக்கிறோம் மற்றும் செயலாக்குகிறோம் என்பதை அடிப்படையில் மாற்றுகிறது. அதன் இதயத்தில் ஒரு சக்திவாய்ந்த கருத்து உள்ளது: டாஸ்க் ஆம்ப்ளிஃபிகேஷன். இது ஒரு சிறிய மேம்படுத்தல் மட்டுமல்ல; இது ஒரு புரட்சிகரமான பாய்ச்சலாகும், இது திட்டமிடல் மற்றும் வடிவியல் உருவாக்கும் தர்க்கத்தை CPU-விலிருந்து நேரடியாக GPU-வின் உயர் இணை கட்டமைப்புக்கு நகர்த்துகிறது, இது முன்னர் ஒரு வலை உலாவியில் நடைமுறைக்கு மாறான அல்லது சாத்தியமற்றதாக இருந்த சாத்தியக்கூறுகளைத் திறக்கிறது.

இந்த விரிவான வழிகாட்டி உங்களை மெஷ் ஷேடர் வடிவியல் பைப்லைனின் ஒரு ஆழமான பார்வைக்கு அழைத்துச் செல்லும். நாம் அதன் கட்டமைப்பை ஆராய்வோம், டாஸ்க் மற்றும் மெஷ் ஷேடர்களின் தனித்துவமான பாத்திரங்களைப் புரிந்துகொள்வோம், மேலும் அடுத்த தலைமுறை பார்வைக்கு பிரமிக்க வைக்கும் மற்றும் செயல்திறன் மிக்க வலை பயன்பாடுகளை உருவாக்க டாஸ்க் ஆம்ப்ளிஃபிகேஷனை எவ்வாறு பயன்படுத்தலாம் என்பதைக் கண்டறிவோம்.

ஒரு விரைவான பின்னோட்டம்: பாரம்பரிய வடிவியல் பைப்லைனின் வரம்புகள்

மெஷ் ஷேடர்களின் புதுமையை உண்மையிலேயே பாராட்ட, முதலில் அவை மாற்றியமைக்கும் பைப்லைனைப் புரிந்து கொள்ள வேண்டும். பல தசாப்தங்களாக, நிகழ்நேர கிராபிக்ஸ் ஒரு ஒப்பீட்டளவில் நிலையான-செயல்பாட்டு பைப்லைனால் ஆதிக்கம் செலுத்தப்பட்டது:

1. வெர்டெக்ஸ் ஷேடர்: தனிப்பட்ட வெர்டெக்ஸ்களை செயலாக்கி, அவற்றை திரை இடத்திற்கு மாற்றுகிறது.
2. (விருப்பத்தேர்வு) டெசலேஷன் ஷேடர்கள்: வடிவியல் பேட்ச்களை பிரித்து நுண்ணிய விவரங்களை உருவாக்குகிறது.
3. (விருப்பத்தேர்வு) ஜியோமெட்ரி ஷேடர்: பிரிமிட்டிவ்களை (புள்ளிகள், கோடுகள், முக்கோணங்கள்) உடனடியாக உருவாக்கலாம் அல்லது அழிக்கலாம்.
4. ராஸ்டரைசர்: பிரிமிட்டிவ்களை பிக்சல்களாக மாற்றுகிறது.
5. ஃபிராக்மென்ட் ஷேடர்: ஒவ்வொரு பிக்சலின் இறுதி நிறத்தையும் கணக்கிடுகிறது.

இந்த மாதிரி நமக்கு நன்றாக சேவை செய்தது, ஆனால் அது உள்ளார்ந்த வரம்புகளைக் கொண்டுள்ளது, குறிப்பாக காட்சிகள் சிக்கலானதாக வளரும்போது:

• CPU-சார்ந்த டிரா கால்கள்: சரியாக என்ன வரையப்பட வேண்டும் என்பதைக் கண்டுபிடிக்கும் மிகப்பெரிய பணி CPU-க்கு உள்ளது. இது ஃபிரஸ்டம் கulling (கேமராவின் பார்வைக்கு வெளியே உள்ள பொருட்களை அகற்றுதல்), ஆக்லூஷன் கulling (மற்ற பொருட்களால் மறைக்கப்பட்ட பொருட்களை அகற்றுதல்), மற்றும் லெவல்-ஆஃப்-டீட்டெய்ல் (LOD) அமைப்புகளை நிர்வகித்தல் ஆகியவற்றை உள்ளடக்கியது. மில்லியன் கணக்கான பொருட்களைக் கொண்ட ஒரு காட்சிக்கு, இது CPU முதன்மைத் தடையாக மாற வழிவகுக்கும், பசியுள்ள GPU-க்கு போதுமான வேகத்தில் தரவை வழங்க முடியாமல் போகும்.
• கடினமான உள்ளீட்டு கட்டமைப்பு: பைப்லைன் ஒரு கடினமான உள்ளீடு-செயலாக்க மாதிரியைச் சுற்றி கட்டமைக்கப்பட்டுள்ளது. உள்ளீட்டு அசெம்ப்ளர் வெர்டெக்ஸ்களை ஒவ்வொன்றாக வழங்குகிறது, மேலும் ஷேடர்கள் அவற்றை ஒப்பீட்டளவில் கட்டுப்படுத்தப்பட்ட முறையில் செயலாக்குகின்றன. இது நவீன GPU கட்டமைப்புகளுக்கு ஏற்றதல்ல, அவை ஒத்திசைவான, இணை தரவு செயலாக்கத்தில் சிறந்து விளங்குகின்றன.
• திறமையற்ற பெருக்கம்: ஜியோமெட்ரி ஷேடர்கள் வடிவியல் பெருக்கத்தை (ஒரு உள்ளீட்டு பிரிமிட்டிவிலிருந்து புதிய முக்கோணங்களை உருவாக்குதல்) அனுமதித்தாலும், அவை மோசமான திறமையற்றவையாக இருந்தன. அவற்றின் வெளியீட்டு நடத்தை வன்பொருளுக்கு கணிக்க முடியாததாக இருந்தது, இது பல பெரிய அளவிலான பயன்பாடுகளுக்கு அவற்றை ஒரு தொடக்கமற்றதாக மாற்றிய செயல்திறன் சிக்கல்களுக்கு வழிவகுத்தது.
• வீணான வேலை: பாரம்பரிய பைப்லைனில், நீங்கள் ஒரு முக்கோணத்தை ரெண்டர் செய்ய அனுப்பினால், வெர்டெக்ஸ் ஷேடர் மூன்று முறை இயங்கும், அந்த முக்கோணம் இறுதியில் கulling செய்யப்பட்டாலும் அல்லது பின்னோக்கி எதிர்கொள்ளும் பிக்சல்-மெல்லிய துண்டாக இருந்தாலும் சரி. இறுதிப் படத்திற்கு எதையும் பங்களிக்காத வடிவியலில் நிறைய செயலாக்க சக்தி செலவிடப்படுகிறது.

முன்னுதாரண மாற்றம்: மெஷ் ஷேடர் பைப்லைனை அறிமுகப்படுத்துதல்

மெஷ் ஷேடர் பைப்லைன், வெர்டெக்ஸ், டெசலேஷன் மற்றும் ஜியோமெட்ரி ஷேடர் நிலைகளை ஒரு புதிய, மேலும் நெகிழ்வான இரண்டு-நிலை மாதிரியுடன் மாற்றுகிறது:

1. டாஸ்க் ஷேடர் (விருப்பத்தேர்வு): எவ்வளவு வேலை செய்ய வேண்டும் என்பதை தீர்மானிக்கும் ஒரு உயர்-நிலை கட்டுப்பாட்டு நிலை. ஆம்ப்ளிஃபிகேஷன் ஷேடர் என்றும் அழைக்கப்படுகிறது.
2. மெஷ் ஷேடர்: "மெஷ்லெட்டுகள்" எனப்படும் சிறிய, தன்னிறைவான வடிவியல் பாக்கெட்டுகளை உருவாக்க தரவுக் கற்றைகளில் செயல்படும் வேலை செய்யும் நிலை.

இந்த புதிய அணுகுமுறை ரெண்டரிங் தத்துவத்தை அடிப்படையில் மாற்றுகிறது. ஒவ்வொரு பொருளுக்கும் ஒவ்வொரு டிரா காலையும் CPU நுணுக்கமாக நிர்வகிப்பதற்கு பதிலாக, அது இப்போது ஒரு சக்திவாய்ந்த ஒற்றை டிரா கட்டளையை வழங்க முடியும், இது அடிப்படையில் GPU-க்கு சொல்கிறது: "இதோ ஒரு சிக்கலான காட்சியின் உயர்-நிலை விளக்கம்; நீங்கள் விவரங்களைக் கண்டுபிடித்துக்கொள்ளுங்கள்."

GPU, டாஸ்க் மற்றும் மெஷ் ஷேடர்களைப் பயன்படுத்தி, கulling, LOD தேர்வு, மற்றும் வழிமுறைசார் உருவாக்கத்தை உயர் இணை முறையில் செய்ய முடியும், உண்மையில் தெரியும் வடிவியலை உருவாக்கத் தேவையான வேலையை மட்டும் தொடங்குகிறது. இது ஒரு GPU-இயக்கப்படும் ரெண்டரிங் பைப்லைனின் சாராம்சம், மேலும் இது செயல்திறன் மற்றும் அளவிடுதலுக்கான ஒரு கேம்-சேஞ்சர் ஆகும்.

நடத்துனர்: டாஸ்க் (ஆம்ப்ளிஃபிகேஷன்) ஷேடரைப் புரிந்துகொள்வது

டாஸ்க் ஷேடர் புதிய பைப்லைனின் மூளை மற்றும் அதன் நம்பமுடியாத சக்திக்கு திறவுகோல். இது ஒரு விருப்பத்தேர்வு நிலை, ஆனால் "ஆம்ப்ளிஃபிகேஷன்" இங்குதான் நடக்கிறது. அதன் முதன்மைப் பங்கு வெர்டெக்ஸ்கள் அல்லது முக்கோணங்களை உருவாக்குவது அல்ல, மாறாக ஒரு வேலை அனுப்புநராக செயல்படுவது.

டாஸ்க் ஷேடர் என்றால் என்ன?

ஒரு டாஸ்க் ஷேடரை ஒரு பெரிய கட்டுமானத் திட்டத்தின் திட்ட மேலாளராக நினைத்துப் பாருங்கள். CPU மேலாளருக்கு "ஒரு நகர மாவட்டத்தை உருவாக்கு" போன்ற ஒரு உயர்-நிலை இலக்கைக் கொடுக்கிறது. திட்ட மேலாளர் (டாஸ்க் ஷேடர்) தானாக செங்கற்களை அடுக்குவதில்லை. அதற்கு பதிலாக, அது ஒட்டுமொத்தப் பணியை மதிப்பிடுகிறது, வரைபடங்களைச் சரிபார்க்கிறது, மேலும் எந்த கட்டுமானக் குழுக்கள் (மெஷ் ஷேடர் வொர்க்குரூப்கள்) தேவை மற்றும் எத்தனை என்று தீர்மானிக்கிறது. அது ஒரு குறிப்பிட்ட கட்டிடம் தேவையில்லை (கulling) அல்லது ஒரு குறிப்பிட்ட பகுதிக்கு பத்து குழுக்கள் தேவைப்படும்போது மற்றொரு பகுதிக்கு இரண்டு மட்டுமே தேவை என்று முடிவு செய்யலாம்.

தொழில்நுட்ப ரீதியாக, ஒரு டாஸ்க் ஷேடர் கணக்கீட்டு போன்ற ஒரு வொர்க்குரூப்பாக இயங்குகிறது. அது நினைவகத்தை அணுகலாம், சிக்கலான கணக்கீடுகளைச் செய்யலாம், மேலும் மிக முக்கியமாக, எத்தனை மெஷ் ஷேடர் வொர்க்குரூப்களைத் தொடங்க வேண்டும் என்பதை முடிவு செய்யலாம். இந்த முடிவு அதன் சக்தியின் மையமாகும்.

ஆம்ப்ளிஃபிகேஷனின் சக்தி

"ஆம்ப்ளிஃபிகேஷன்" என்ற சொல், டாஸ்க் ஷேடரின் அதன் சொந்த ஒரு வொர்க்குரூப்பை எடுத்து பூஜ்ஜியம், ஒன்று அல்லது பல மெஷ் ஷேடர் வொர்க்குரூப்களைத் தொடங்கும் திறனிலிருந்து வருகிறது. இந்தத் திறன் உருமாற்றமளிக்கிறது:

• பூஜ்ஜியத்தை தொடங்குதல்: ஒரு பொருள் அல்லது காட்சியின் ஒரு பகுதி தெரியவில்லை என்று டாஸ்க் ஷேடர் தீர்மானித்தால் (உதாரணமாக, கேமராவின் ஃபிரஸ்டத்திற்கு வெளியே), அது வெறுமனே பூஜ்ஜியம் மெஷ் ஷேடர் வொர்க்குரூப்களைத் தொடங்க தேர்வு செய்யலாம். அந்தப் பொருளுடன் தொடர்புடைய அனைத்து சாத்தியமான வேலைகளும் மேலும் செயலாக்கப்படாமல் மறைந்துவிடும். இது GPU-வில் முழுமையாக செய்யப்படும் நம்பமுடியாத திறமையான கulling ஆகும்.
• ஒன்றை தொடங்குதல்: இது ஒரு நேரடி கடந்து செல்லுதல். டாஸ்க் ஷேடர் வொர்க்குரூப் ஒரு மெஷ் ஷேடர் வொர்க்குரூப் தேவை என்று முடிவு செய்கிறது.
• பலவற்றை தொடங்குதல்: வழிமுறைசார் உருவாக்கத்திற்கான மேஜிக் இங்குதான் நடக்கிறது. ஒரு ஒற்றை டாஸ்க் ஷேடர் வொர்க்குரூப் சில உள்ளீட்டு அளவுருக்களை பகுப்பாய்வு செய்து ஆயிரக்கணக்கான மெஷ் ஷேடர் வொர்க்குரூப்களைத் தொடங்க முடிவு செய்யலாம். உதாரணமாக, இது ஒரு புல்வெளியில் உள்ள ஒவ்வொரு புல்லுக்கும் அல்லது ஒரு அடர்த்தியான தொகுப்பில் உள்ள ஒவ்வொரு சிறுகோளுக்கும் ஒரு வொர்க்குரூப்பைத் தொடங்கலாம், இவை அனைத்தும் CPU-விலிருந்து வரும் ஒரு ஒற்றை அனுப்புதல் கட்டளையிலிருந்து.

டாஸ்க் ஷேடர் GLSL-இன் ஒரு கருத்தியல் பார்வை

விவரங்கள் சிக்கலானதாக மாறினாலும், GLSL-இல் (WebGL நீட்டிப்புக்கு) உள்ள முக்கிய பெருக்க வழிமுறை ஆச்சரியப்படும் விதமாக எளிமையானது. இது `EmitMeshTasksEXT()` செயல்பாட்டைச் சுற்றியே சுழல்கிறது.

குறிப்பு: இது ஒரு எளிமைப்படுத்தப்பட்ட, கருத்தியல் எடுத்துக்காட்டு.

#version 310 es #extension GL_EXT_mesh_shader : require layout(local_size_x = 32, local_size_y = 1, local_size_z = 1) in; // CPU-விலிருந்து அனுப்பப்பட்ட யூனிபார்ம்கள் uniform mat4 u_viewProjectionMatrix; uniform uint u_totalObjectCount; // பல பொருட்களுக்கான எல்லைக் கோளங்களைக் கொண்ட ஒரு பஃபர் struct BoundingSphere { vec4 centerAndRadius; }; layout(std430, binding = 0) readonly buffer ObjectBounds { BoundingSphere bounds[]; } objectBounds; void main() { // வொர்க்குரூப்பில் உள்ள ஒவ்வொரு த்ரெட்டும் ஒரு ভিন্ন பொருளைச் சரிபார்க்கலாம் uint objectIndex = gl_GlobalInvocationID.x; if (objectIndex >= u_totalObjectCount) { return; } // இந்த பொருளின் எல்லைக் கோளத்தில் GPU-வில் ஃபிரஸ்டம் கulling செய்யவும் BoundingSphere sphere = objectBounds.bounds[objectIndex]; bool isVisible = isSphereInFrustum(sphere.centerAndRadius, u_viewProjectionMatrix); // அது தெரிந்தால், அதை வரைய ஒரு மெஷ் ஷேடர் வொர்க்குரூப்பைத் தொடங்கவும். // குறிப்பு: இந்த தர்க்கம் மிகவும் சிக்கலானதாக இருக்கலாம், தெரியும் பொருட்களை எண்ணுவதற்கு // அணுக்களைப் பயன்படுத்துதல் மற்றும் ஒரு த்ரெட் அவை அனைத்திற்கும் அனுப்புதல். if (isVisible) { // இது GPU-க்கு ஒரு மெஷ் டாஸ்கைத் தொடங்கச் சொல்கிறது. அளவுருக்கள் மெஷ் ஷேடர் // வொர்க்குரூப்பிற்கு தகவலை அனுப்ப பயன்படுத்தப்படலாம். // எளிமைக்காக, ஒவ்வொரு டாஸ்க் ஷேடர் அழைப்பும் நேரடியாக ஒரு மெஷ் டாஸ்க்கு வரைபடமாக்கப்படும் என்று கற்பனை செய்கிறோம். // ஒரு யதார்த்தமான காட்சி ஒரு த்ரெட்டிலிருந்து குழுவாக்கம் மற்றும் அனுப்புவதை உள்ளடக்கியது. // ஒரு எளிமைப்படுத்தப்பட்ட கருத்தியல் அனுப்புதல்: // ஒவ்வொரு தெரியும் பொருளுக்கும் அதன் சொந்த டாஸ்க் கிடைக்கும் என்று நாம் பாசாங்கு செய்வோம், இருப்பினும் உண்மையில் // ஒரு டாஸ்க் ஷேடர் அழைப்பு பல மெஷ் ஷேடர்களை அனுப்புவதை நிர்வகிக்கும். EmitMeshTasksEXT(1u, 0u, 0u); // இது முக்கிய பெருக்கச் செயல்பாடு } // தெரியவில்லை என்றால், நாம் ஒன்றும் செய்ய மாட்டோம்! இந்தச் சரிபார்ப்புக்கு அப்பால் பூஜ்ஜிய GPU செலவில் பொருள் கulling செய்யப்படுகிறது. }

ஒரு நிஜ-உலக சூழ்நிலையில், வொர்க்குரூப்பில் உள்ள ஒரு த்ரெட் முடிவுகளை ஒருங்கிணைத்து, வொர்க்குரூப் பொறுப்பேற்றுள்ள அனைத்து தெரியும் பொருட்களுக்கும் ஒரு ஒற்றை `EmitMeshTasksEXT` அழைப்பைச் செய்யலாம்.

பணியாளர்கள்: வடிவியல் உருவாக்கத்தில் மெஷ் ஷேடரின் பங்கு

ஒரு டாஸ்க் ஷேடர் ஒன்று அல்லது அதற்கு மேற்பட்ட வொர்க்குரூப்களை அனுப்பியவுடன், மெஷ் ஷேடர் பொறுப்பேற்கிறது. டாஸ்க் ஷேடர் திட்ட மேலாளராக இருந்தால், மெஷ் ஷேடர் உண்மையில் வடிவியலைக் கட்டும் திறமையான கட்டுமானக் குழுவாகும்.

வொர்க்குரூப்களிலிருந்து மெஷ்லெட்டுகளுக்கு

ஒரு டாஸ்க் ஷேடரைப் போலவே, ஒரு மெஷ் ஷேடரும் த்ரெட்களின் ஒரு கூட்டுறவு வொர்க்குரூப்பாக இயங்குகிறது. இந்த முழு வொர்க்குரூப்பின் கூட்டு இலக்கு மெஷ்லெட் எனப்படும் ஒரு சிறிய வடிவியல் தொகுப்பை உருவாக்குவதாகும். ஒரு மெஷ்லெட் என்பது வெறுமனே வெர்டெக்ஸ்கள் மற்றும் அவற்றை இணைக்கும் பிரிமிட்டிவ்களின் (முக்கோணங்கள்) ஒரு தொகுப்பாகும். பொதுவாக, ஒரு மெஷ்லெட் ஒரு சிறிய எண்ணிக்கையிலான வெர்டெக்ஸ்கள் (எ.கா., 128 வரை) மற்றும் முக்கோணங்கள் (எ.கா., 256 வரை) கொண்டிருக்கும், இது நவீன GPU கேஷ்கள் மற்றும் செயலாக்க மாதிரிகளுக்கு மிகவும் நட்பான ஒரு அளவு.

இது வெர்டெக்ஸ் ஷேடரிலிருந்து ஒரு அடிப்படை விலகலாகும், அதற்கு அதன் அண்டை வீட்டாரைப் பற்றிய கருத்து இல்லை. ஒரு மெஷ் ஷேடரில், வொர்க்குரூப்பில் உள்ள அனைத்து த்ரெட்களும் நினைவகத்தைப் பகிர்ந்து கொள்ளலாம் மற்றும் மெஷ்லெட்டை திறமையாக உருவாக்க தங்கள் முயற்சிகளை ஒருங்கிணைக்கலாம்.

வெர்டெக்ஸ்கள் மற்றும் பிரிமிட்டிவ்களை உருவாக்குதல்

ஒற்றை `gl_Position`-ஐத் திருப்புவதற்குப் பதிலாக, ஒரு மெஷ் ஷேடர் வொர்க்குரூப் அதன் மெஷ்லெட்டிற்கான முழுமையான தரவுகளுடன் வெளியீட்டு வரிசைகளை நிரப்புகிறது. த்ரெட்கள் ஒன்றாகச் சேர்ந்து வெர்டெக்ஸ் நிலைகள், நார்மல்கள், UV ஒருங்கிணைப்புகள் மற்றும் பிற பண்புகளை இந்த வரிசைகளில் எழுதுகின்றன. அவை ஒவ்வொரு முக்கோணத்தையும் எந்த வெர்டெக்ஸ்கள் உருவாக்குகின்றன என்பதைக் குறிப்பிடுவதன் மூலம் பிரிமிட்டிவ்களையும் வரையறுக்கின்றன.

ஒரு மெஷ் ஷேடரின் இறுதிப் படி, அது சரியாக எத்தனை வெர்டெக்ஸ்கள் மற்றும் பிரிமிட்டிவ்களை உருவாக்கியுள்ளது என்பதை அறிவிக்க `SetMeshOutputsEXT()` போன்ற ஒரு செயல்பாட்டை அழைப்பதாகும். பின்னர் வன்பொருள் இந்த மெஷ்லெட்டை எடுத்து அதை நேரடியாக ராஸ்டரைசருக்கு அனுப்புகிறது.

மெஷ் ஷேடர் GLSL-இன் ஒரு கருத்தியல் பார்வை

இங்கே ஒரு மெஷ் ஷேடர் ஒரு எளிய குவாடை உருவாக்கும் ஒரு கருத்தியல் எடுத்துக்காட்டு உள்ளது. த்ரெட்கள் அவற்றின் `gl_LocalInvocationID`-ஐ அடிப்படையாகக் கொண்டு எவ்வாறு ஒத்துழைக்கின்றன என்பதைக் கவனியுங்கள்.

#version 310 es #extension GL_EXT_mesh_shader : require // நமது மெஷ்லெட்டிற்கான அதிகபட்ச வெளியீடுகளை வரையறுக்கவும் layout(max_vertices = 4, max_primitives = 2) out; layout(triangles) out; layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in; // நாம் இந்த உள்ளமைக்கப்பட்ட வெளியீட்டு வரிசைகளில் வெர்டெக்ஸ் தரவை எழுதுகிறோம் out gl_MeshVerticesEXT { vec4 position; vec2 uv; } vertices[]; // நாம் இந்த வரிசைக்கு முக்கோண குறியீடுகளை எழுதுகிறோம் out uint gl_MeshPrimitivesEXT[]; uniform mat4 u_modelViewProjectionMatrix; void main() { // இந்த மெஷ்லெட்டிற்கு உருவாக்க வேண்டிய மொத்த வெர்டெக்ஸ்கள் மற்றும் பிரிமிட்டிவ்கள் const uint vertexCount = 4; const uint primitiveCount = 2; // நாம் உண்மையில் எத்தனை வெர்டெக்ஸ்கள் மற்றும் பிரிமிட்டிவ்களை வெளியிடுகிறோம் என்பதை வன்பொருளுக்குச் சொல்லுங்கள் SetMeshOutputsEXT(vertexCount, primitiveCount); // ஒரு குவாடுக்கான வெர்டெக்ஸ் நிலைகள் மற்றும் UV-களை வரையறுக்கவும் vec4 positions[4] = vec4[4]( vec4(-0.5, 0.5, 0.0, 1.0), vec4(-0.5, -0.5, 0.0, 1.0), vec4(0.5, 0.5, 0.0, 1.0), vec4(0.5, -0.5, 0.0, 1.0) ); vec2 uvs[4] = vec2[4]( vec2(0.0, 1.0), vec2(0.0, 0.0), vec2(1.0, 1.0), vec2(1.0, 0.0) ); // வொர்க்குரூப்பில் உள்ள ஒவ்வொரு த்ரெட்டும் ஒரு வெர்டெக்ஸை உருவாக்கட்டும் uint id = gl_LocalInvocationID.x; if (id < vertexCount) { vertices[id].position = u_modelViewProjectionMatrix * positions[id]; vertices[id].uv = uvs[id]; } // முதல் இரண்டு த்ரெட்கள் குவாடுக்கான இரண்டு முக்கோணங்களை உருவாக்கட்டும் if (id == 0) { // முதல் முக்கோணம்: 0, 1, 2 gl_MeshPrimitivesEXT[0] = 0u; gl_MeshPrimitivesEXT[1] = 1u; gl_MeshPrimitivesEXT[2] = 2u; } if (id == 1) { // இரண்டாவது முக்கோணம்: 1, 3, 2 gl_MeshPrimitivesEXT[3] = 1u; gl_MeshPrimitivesEXT[4] = 3u; gl_MeshPrimitivesEXT[5] = 2u; } }

நடைமுறை மேஜிக்: டாஸ்க் ஆம்ப்ளிஃபிகேஷனுக்கான பயன்பாட்டு வழக்குகள்

இந்த பைப்லைனின் உண்மையான சக்தி, சிக்கலான, நிஜ-உலக ரெண்டரிங் சவால்களுக்கு நாம் அதைப் பயன்படுத்தும்போது வெளிப்படுகிறது.

பயன்பாட்டு வழக்கு 1: மிகப்பெரிய வழிமுறைசார் வடிவியல் உருவாக்கம்

நூறாயிரக்கணக்கான தனித்துவமான சிறுகோள்களுடன் கூடிய அடர்த்தியான சிறுகோள் புலத்தை ரெண்டர் செய்வதை கற்பனை செய்து பாருங்கள். பழைய பைப்லைனுடன், CPU ஒவ்வொரு சிறுகோளின் வெர்டெக்ஸ் தரவையும் உருவாக்கி, ஒவ்வொன்றிற்கும் ஒரு தனி டிரா காலை வழங்க வேண்டும், இது முற்றிலும் தாங்க முடியாத அணுகுமுறை.

மெஷ் ஷேடர் பணிப்பாய்வு:

1. CPU ஒரு ஒற்றை டிரா காலை வெளியிடுகிறது: `drawMeshTasksEXT(1, 1)`. இது புலத்தின் ஆரம் மற்றும் சிறுகோள் அடர்த்தி போன்ற சில உயர்-நிலை அளவுருக்களையும் ஒரு யூனிபார்ம் பஃபரில் அனுப்புகிறது.
2. ஒரு ஒற்றை டாஸ்க் ஷேடர் வொர்க்குரூப் செயல்படுகிறது. அது அளவுருக்களைப் படித்து, சுமார் 50,000 சிறுகோள்கள் தேவை என்று கணக்கிடுகிறது. பின்னர் அது `EmitMeshTasksEXT(50000, 0, 0)`-ஐ அழைக்கிறது.
3. GPU இணையாக 50,000 மெஷ் ஷேடர் வொர்க்குரூப்களைத் தொடங்குகிறது.
4. ஒவ்வொரு மெஷ் ஷேடர் வொர்க்குரூப்பும் அதன் தனித்துவமான ஐடியை (`gl_WorkGroupID`) ஒரு விதையாகப் பயன்படுத்தி ஒரு தனித்துவமான சிறுகோளுக்கான வெர்டெக்ஸ்கள் மற்றும் முக்கோணங்களை வழிமுறை ரீதியாக உருவாக்குகிறது.

இதன் விளைவாக, GPU-வில் கிட்டத்தட்ட முழுமையாக உருவாக்கப்பட்ட ஒரு பெரிய, சிக்கலான காட்சி, CPU-ஐ இயற்பியல் மற்றும் AI போன்ற பிற பணிகளைக் கையாள விடுவிக்கிறது.

பயன்பாட்டு வழக்கு 2: ஒரு பெரிய அளவில் GPU-இயக்கப்படும் கulling

மில்லியன் கணக்கான தனிப்பட்ட பொருட்களுடன் கூடிய ஒரு விரிவான நகரக் காட்சியை கருத்தில் கொள்ளுங்கள். CPU வெறுமனே ஒவ்வொரு ஃபிரேமிலும் ஒவ்வொரு பொருளின் தெரிவுநிலையையும் சரிபார்க்க முடியாது.

மெஷ் ஷேடர் பணிப்பாய்வு:

1. CPU காட்சியில் உள்ள ஒவ்வொரு பொருளுக்கும் எல்லை அளவுகளை (எ.கா., கோளங்கள் அல்லது பெட்டிகள்) கொண்ட ஒரு பெரிய பஃபரை பதிவேற்றுகிறது. இது ஒருமுறை நடக்கும், அல்லது பொருட்கள் நகரும்போது மட்டுமே நடக்கும்.
2. CPU ஒரு ஒற்றை டிரா காலை வெளியிடுகிறது, எல்லை அளவுகளின் முழு பட்டியலையும் இணையாக செயலாக்க போதுமான டாஸ்க் ஷேடர் வொர்க்குரூப்களைத் தொடங்குகிறது.
3. ஒவ்வொரு டாஸ்க் ஷேடர் வொர்க்குரூப்பிற்கும் எல்லை அளவு பட்டியலின் ஒரு பகுதி ஒதுக்கப்படுகிறது. அது அதன் ஒதுக்கப்பட்ட பொருட்கள் வழியாகச் சென்று, ஒவ்வொன்றிற்கும் ஃபிரஸ்டம் கulling (மற்றும் சாத்தியமான ஆக்லூஷன் கulling) செய்கிறது, மேலும் எத்தனை தெரிகின்றன என்று கணக்கிடுகிறது.
4. இறுதியாக, அது தெரியும் பொருட்களின் ஐடிகளை அனுப்பிக்கொண்டு, சரியாக அந்த எண்ணிக்கையிலான மெஷ் ஷேடர் வொர்க்குரூப்களைத் தொடங்குகிறது.
5. ஒவ்வொரு மெஷ் ஷேடர் வொர்க்குரூப்பும் ஒரு பொருள் ஐடியைப் பெறுகிறது, ஒரு பஃபரிலிருந்து அதன் மெஷ் தரவைத் தேடுகிறது, மேலும் ரெண்டரிங்கிற்கான தொடர்புடைய மெஷ்லெட்டுகளை உருவாக்குகிறது.

இது முழு கulling செயல்முறையையும் GPU-க்கு நகர்த்துகிறது, இது ஒரு CPU-அடிப்படையிலான அணுகுமுறையை உடனடியாக முடக்கும் ஒரு சிக்கலான காட்சிகளை அனுமதிக்கிறது.

பயன்பாட்டு வழக்கு 3: டைனமிக் மற்றும் திறமையான லெவல்-ஆஃப்-டீட்டெய்ல் (LOD)

LOD அமைப்புகள் செயல்திறனுக்கு முக்கியமானவை, தொலைவில் உள்ள பொருட்களுக்கு எளிமையான மாடல்களுக்கு மாறுகின்றன. மெஷ் ஷேடர்கள் இந்த செயல்முறையை மேலும் நுணுக்கமாகவும் திறமையாகவும் ஆக்குகின்றன.

மெஷ் ஷேடர் பணிப்பாய்வு:

1. ஒரு பொருளின் தரவு மெஷ்லெட்டுகளின் ஒரு படிநிலையாக முன்-செயலாக்கப்படுகிறது. கரடுமுரடான LOD-கள் குறைவான, பெரிய மெஷ்லெட்டுகளைப் பயன்படுத்துகின்றன.
2. இந்த பொருளுக்கான ஒரு டாஸ்க் ஷேடர் கேமராவிலிருந்து அதன் தூரத்தைக் கணக்கிடுகிறது.
3. தூரத்தின் அடிப்படையில், எந்த LOD நிலை பொருத்தமானது என்பதை அது தீர்மானிக்கிறது. பின்னர் அது அந்த LOD-க்கு ஒரு மெஷ்லெட் அடிப்படையில் கulling செய்ய முடியும். உதாரணமாக, ஒரு பெரிய பொருளுக்கு, அது பொருளின் பின் பக்கத்தில் உள்ள தெரியாத மெஷ்லெட்டுகளை கulling செய்ய முடியும்.
4. அது தேர்ந்தெடுக்கப்பட்ட LOD-இன் தெரியும் மெஷ்லெட்டுகளுக்கான மெஷ் ஷேடர் வொர்க்குரூப்களை மட்டுமே தொடங்குகிறது.

இது CPU முழு மாதிரிகளையும் மாற்றுவதை விட மிகவும் திறமையான, நுணுக்கமான, உடனடி LOD தேர்வு மற்றும் கulling-ஐ அனுமதிக்கிறது.

தொடங்குதல்: `WEBGL_mesh_shader` நீட்டிப்பைப் பயன்படுத்துதல்

சோதனை செய்யத் தயாரா? WebGL-இல் மெஷ் ஷேடர்களுடன் தொடங்குவதற்கான நடைமுறைப் படிகள் இங்கே உள்ளன.

ஆதரவைச் சரிபார்த்தல்

முதலாவதாக, இது ஒரு அதிநவீன அம்சம். பயனரின் உலாவி மற்றும் வன்பொருள் அதை ஆதரிக்கிறதா என்பதை நீங்கள் சரிபார்க்க வேண்டும்.

const gl = canvas.getContext('webgl2'); const meshShaderExtension = gl.getExtension('WEBGL_mesh_shader'); if (!meshShaderExtension) { console.error("உங்கள் உலாவி அல்லது GPU WEBGL_mesh_shader-ஐ ஆதரிக்கவில்லை."); // ஒரு பாரம்பரிய ரெண்டரிங் பாதைக்குத் திரும்புங்கள் }

புதிய டிரா கால்

`drawArrays` மற்றும் `drawElements`-ஐ மறந்துவிடுங்கள். புதிய பைப்லைன் ஒரு புதிய கட்டளையுடன் அழைக்கப்படுகிறது. `getExtension`-இலிருந்து நீங்கள் பெறும் நீட்டிப்புப் பொருள் புதிய செயல்பாடுகளைக் கொண்டிருக்கும்.

// 10 டாஸ்க் ஷேடர் வொர்க்குரூப்களைத் தொடங்கவும். // ஒவ்வொரு வொர்க்குரூப்பும் ஷேடரில் வரையறுக்கப்பட்ட உள்ளூர்_அளவைக் கொண்டிருக்கும். meshShaderExtension.drawMeshTasksEXT(0, 10);

`count` வாதம் டாஸ்க் ஷேடரின் எத்தனை உள்ளூர் வொர்க்குரூப்களைத் தொடங்க வேண்டும் என்பதைக் குறிப்பிடுகிறது. நீங்கள் ஒரு டாஸ்க் ஷேடரைப் பயன்படுத்தவில்லை என்றால், இது நேரடியாக மெஷ் ஷேடர் வொர்க்குரூப்களைத் தொடங்குகிறது.

ஷேடர் தொகுத்தல் மற்றும் இணைத்தல்

செயல்முறை பாரம்பரிய GLSL-ஐப் போன்றது, ஆனால் நீங்கள் `meshShaderExtension.MESH_SHADER_EXT` மற்றும் `meshShaderExtension.TASK_SHADER_EXT` வகையிலான ஷேடர்களை உருவாக்குவீர்கள். நீங்கள் ஒரு வெர்டெக்ஸ் மற்றும் ஃபிராக்மென்ட் ஷேடரைப் போலவே அவற்றை ஒரு புரோகிராமில் ஒன்றாக இணைப்பீர்கள்.

முக்கியமாக, உங்கள் இரண்டு ஷேடர்களுக்கான GLSL மூலக் குறியீடும் நீட்டிப்பை இயக்குவதற்கான கட்டளையுடன் தொடங்க வேண்டும்:

#extension GL_EXT_mesh_shader : require

செயல்திறன் பரிசீலனைகள் மற்றும் சிறந்த நடைமுறைகள்

• சரியான வொர்க்குரூப் அளவைத் தேர்ந்தெடுக்கவும்: உங்கள் ஷேடரில் உள்ள `layout(local_size_x = N)` முக்கியமானது. 32 அல்லது 64 அளவு பெரும்பாலும் ஒரு நல்ல தொடக்கப் புள்ளியாகும், ஏனெனில் இது அடிப்படை வன்பொருள் கட்டமைப்புகளுடன் நன்றாகப் பொருந்துகிறது, ஆனால் உங்கள் குறிப்பிட்ட பணிச்சுமைக்கு உகந்த அளவைக் கண்டுபிடிக்க எப்போதும் சுயவிவரம் செய்யுங்கள்.
• உங்கள் டாஸ்க் ஷேடரை மெலிதாக வைத்திருங்கள்: டாஸ்க் ஷேடர் ஒரு சக்திவாய்ந்த கருவி, ஆனால் அது ஒரு சாத்தியமான தடையாகவும் உள்ளது. நீங்கள் இங்கு செய்யும் கulling மற்றும் தர்க்கம் முடிந்தவரை திறமையாக இருக்க வேண்டும். மெதுவான, சிக்கலான கணக்கீடுகளை முன்கூட்டியே கணக்கிட முடிந்தால் தவிர்க்கவும்.
• மெஷ்லெட் அளவை மேம்படுத்தவும்: ஒரு மெஷ்லெட்டிற்கு வெர்டெக்ஸ்கள் மற்றும் பிரிமிட்டிவ்களின் எண்ணிக்கைக்கு ஒரு வன்பொருள்-சார்ந்த இனிமையான புள்ளி உள்ளது. நீங்கள் அறிவிக்கும் `max_vertices` மற்றும் `max_primitives` கவனமாக தேர்ந்தெடுக்கப்பட வேண்டும். மிகச் சிறியதாக இருந்தால், வொர்க்குரூப்களைத் தொடங்கும் மேல்நிலை ஆதிக்கம் செலுத்துகிறது. மிக அதிகமாக இருந்தால், நீங்கள் இணைத்துவம் மற்றும் கேச் செயல்திறனை இழக்கிறீர்கள்.
• தரவு ஒத்திசைவு முக்கியம்: டாஸ்க் ஷேடரில் கulling செய்யும்போது, ஒத்திசைவான அணுகல் முறைகளை ஊக்குவிக்க உங்கள் எல்லை அளவு தரவை நினைவகத்தில் ஏற்பாடு செய்யுங்கள். இது GPU கேஷ்கள் திறம்பட செயல்பட உதவுகிறது.
• அவற்றை எப்போது தவிர்க்க வேண்டும் என்பதை அறிந்து கொள்ளுங்கள்: மெஷ் ஷேடர்கள் ஒரு மந்திரக்கோல் அல்ல. ஒரு சில எளிய பொருட்களை ரெண்டர் செய்வதற்கு, மெஷ் பைப்லைனின் மேல்நிலை பாரம்பரிய வெர்டெக்ஸ் பைப்லைனை விட மெதுவாக இருக்கலாம். அவற்றின் பலம் பிரகாசிக்கும் இடங்களில் அவற்றைப் பயன்படுத்தவும்: பாரிய பொருள் எண்ணிக்கைகள், சிக்கலான வழிமுறைசார் உருவாக்கம் மற்றும் GPU-இயக்கப்படும் பணிச்சுமைகள்.

முடிவு: இணையத்தில் நிகழ்நேர கிராபிக்ஸின் எதிர்காலம் இப்போது

டாஸ்க் ஆம்ப்ளிஃபிகேஷனுடன் கூடிய மெஷ் ஷேடர் பைப்லைன் கடந்த தசாப்தத்தில் நிகழ்நேர கிராபிக்ஸில் ஏற்பட்ட மிக முக்கியமான முன்னேற்றங்களில் ஒன்றாகும். ஒரு கடினமான, CPU-நிர்வகிக்கப்பட்ட செயல்முறையிலிருந்து ஒரு நெகிழ்வான, GPU-இயக்கப்படும் ஒன்றுக்கு முன்னுதாரணத்தை மாற்றுவதன் மூலம், இது வடிவியல் சிக்கலான தன்மை மற்றும் காட்சி அளவிற்கான முந்தைய தடைகளை உடைக்கிறது.

இந்தத் தொழில்நுட்பம், வல்கன், டைரக்ட்எக்ஸ் 12 அல்டிமேட் மற்றும் மெட்டல் போன்ற நவீன கிராபிக்ஸ் ஏபிஐகளின் திசையுடன் ஒத்துப்போகிறது, இது இனி உயர்நிலை நேட்டிவ் பயன்பாடுகளுக்கு மட்டும் সীমাবদ্ধ இல்லை. WebGL-இல் அதன் வருகை, முன்னெப்போதையும் விட மிகவும் விரிவான, டைனமிக் மற்றும் அதிவேகமான வலை அடிப்படையிலான அனுபவங்களின் ஒரு புதிய சகாப்தத்திற்கு கதவைத் திறக்கிறது. இந்த புதிய மாதிரியைத் தழுவத் தயாராக இருக்கும் டெவலப்பர்களுக்கு, படைப்பு சாத்தியக்கூறுகள் கிட்டத்தட்ட வரம்பற்றவை. முழு உலகங்களையும் உடனடியாக உருவாக்கும் சக்தி, முதல் முறையாக, உண்மையில் உங்கள் விரல் நுனியில், ஒரு வலை உலாவிக்குள் உள்ளது.