Vertex Shader: यह क्या है, कार्य और कार्य सिद्धांत

Vertex Shader क्या है?

Vertex Shader ग्राफिक्स पाइपलाइन का एक प्रोग्रामेबल चरण है जो 3D मॉडल के प्रत्येक वर्टेक्स को व्यक्तिगत रूप से प्रोसेस करता है। वर्टेक्स त्रि-आयामी अंतरिक्ष में एक बिंदु है जिसमें विशेषताएँ होती हैं: xyz निर्देशांक, नॉर्मल, रंग और UV टेक्सचर निर्देशांक।

फिक्स्ड-फंक्शन पाइपलाइन के विपरीत, जहाँ रूपांतरण एक कठोर एल्गोरिदम के अनुसार किए जाते थे, Vertex Shader डेवलपर को वर्टेक्स रूपांतरण पर पूर्ण नियंत्रण देता है। यह प्रोसीजरल एनिमेशन, मॉडल विरूपण, कंकाल स्किनिंग और GPU पक्ष पर किसी भी गणितीय रूपांतरण को लागू करने की अनुमति देता है।

ग्राफिक्स पाइपलाइन में Vertex Shader का स्थान

OpenGL ES ग्राफिक्स पाइपलाइन में इनपुट डेटा से अंतिम छवि तक चरणों का एक क्रम शामिल है। Vertex Shader वर्टेक्स असेंबली चरण के बाद और रेस्टराइज़ेशन चरण से पहले स्थित है। CPU से वर्टेक्स बफर के माध्यम से भेजा गया प्रत्येक वर्टेक्स Vertex Shader से ठीक एक बार गुज़रता है, और परिणाम प्रिमिटिव असेंबली के लिए अगले चरण में भेजा जाता है।

Vertex Shader कैसे काम करता है?

Vertex Shader CPU कोड में कॉन्फ़िगर किए गए वर्टेक्स एट्रीब्यूट पॉइंटर्स के माध्यम से वर्टेक्स बफर (VBO) से वर्टेक्स विशेषताएँ प्राप्त करता है। डेवलपर GLSL (OpenGL Shading Language) या समकक्ष भाषा में शेडर कोड लिखता है, जिसे GPU ड्राइवर विशिष्ट चिप के लिए मशीन निर्देशों में संकलित करता है।

वर्टेक्स प्रसंस्करण प्रवाह

प्रत्येक वर्टेक्स के लिए, Vertex Shader क्रमिक रूप से तीन ऑपरेशन करता है: इनपुट विशेषताओं को पढ़ना — डेवलपर द्वारा परिभाषित रूपांतरण लागू करना — आउटपुट वेरिएबल में परिणाम लिखना। न्यूनतम आवश्यक आउटपुट क्लिप स्पेस में वर्टेक्स स्थिति (gl_Position) है। अन्य सभी आउटपुट डेटा (रंग, नॉर्मल, टेक्सचर निर्देशांक) इंटरपोलेट होते हैं और अगले चरण — Fragment Shader को भेजे जाते हैं।

#version 300 es
in vec3 aPosition;
in vec2 aTexCoord;
uniform mat4 uMVP;
out vec2 vTexCoord;

void main() {
    gl_Position = uMVP * vec4(aPosition, 1.0);
    vTexCoord = aTexCoord;
}

Vertex Shader के मुख्य कार्य

Vertex Shader ज्यामिति रूपांतरण से संबंधित ग्राफिक्स पाइपलाइन कार्यों की एक विस्तृत श्रृंखला को हल करता है। प्रत्येक कार्य वैक्टर और मैट्रिसेस पर गणितीय संक्रियाओं के माध्यम से कार्यान्वित किया जाता है, जो हजारों वर्टेक्स के लिए समानांतर रूप से निष्पादित होता है।

MVP के माध्यम से निर्देशांक रूपांतरण

मूल और सबसे सामान्य कार्य वर्टेक्स निर्देशांकों को model, view और projection (MVP) मैट्रिसेस से गुणा करना है। MVP मैट्रिक्स वर्टेक्स को स्थानीय मॉडल स्पेस से क्लिप स्पेस में रूपांतरित करता है, जिसे फिर पाइपलाइन के स्वचालित चरणों में सामान्यीकृत और स्क्रीन निर्देशांक में परिवर्तित किया जाता है।

कंकाल एनिमेशन (Skinning)

एनिमेटेड पात्रों के लिए, Vertex Shader कंकाल एनिमेशन (skinning) लागू करता है। प्रत्येक वर्टेक्स विशिष्ट भार के साथ कई हड्डियों से बंधा होता है। Vertex blending — बंधी हड्डियों से रूपांतरणों का भारित योग — कंकाल के चलने पर चरित्र की त्वचा को सुचारू रूप से विकृत करने की अनुमति देता है।

प्रोसीजरल ज्यामिति विरूपण

Vertex Shader CPU की भागीदारी के बिना समय या अन्य uniform पैरामीटर के आधार पर ज्यामिति को संशोधित कर सकता है। Wave deformation, पर्लिन नॉइज़ विस्थापन और पानी की लहर प्रभाव — ये सभी प्रभाव RAM से ज्यामिति को पुनः लोड किए बिना वर्टेक्स शेडर में कार्यान्वित किए जाते हैं।

Vertex Shader बनाम Fragment Shader: अंतर

हालाँकि दोनों प्रकार के शेडर ग्राफिक्स पाइपलाइन के प्रोग्रामेबल चरण हैं, Vertex Shader और Fragment Shader मौलिक रूप से भिन्न कार्यों को हल करते हैं और छवि प्रसंस्करण के विभिन्न चरणों में काम करते हैं।

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

Vertex Shader का प्रदर्शन और अनुकूलन

Vertex Shader का प्रदर्शन रीयल-टाइम अनुप्रयोगों के लिए अत्यंत महत्वपूर्ण है, विशेष रूप से सीमित बिजली खपत वाले मोबाइल डेवलपमेंट में। मुख्य प्रदर्शन कारक वर्टेक्स की संख्या, शेडर कोड जटिलता और GPU मेमोरी बैंडविड्थ हैं।

प्रदर्शन को प्रभावित करने वाले कारक

• वर्टेक्स संख्या — प्रति फ्रेम GPU को भेजे जाने वाले वर्टेक्स की संख्या। लाखों पॉलीगॉन वाले मॉडल वर्टेक्स शेडर पर उच्च भार डालते हैं।
• शेडर जटिलता — शेडर में निर्देशों की संख्या। नेस्टेड लूप और सशर्त शाखाएँ (divergence) SIMD इकाइयों के समानांतर प्रदर्शन को कम करती हैं।
• बैंडविड्थ — वीडियो मेमोरी से वर्टेक्स डेटा पढ़ने की गति। विशेषताओं का प्रारूप (float32, float16, सामान्यीकृत पूर्णांक) सीधे थ्रूपुट को प्रभावित करता है।

वर्टेक्स शेडर अनुकूलन विधियाँ

Vertex Shader पर भार कम करने के लिए निम्नलिखित दृष्टिकोणों का उपयोग किया जाता है। Level of Detail (LOD) — कैमरा वस्तु से दूर जाने पर मॉडल के सरलीकृत संस्करणों पर स्विच करना। Instancing — एक ड्रा कॉल में विभिन्न रूपांतरण मैट्रिसेस के साथ एक ही ज्यामिति को कई बार चित्रित करना।

// instancing समर्थन के साथ Vertex Shader
in vec3 aPosition;
in mat4 aInstanceMatrix;
uniform mat4 uViewProjection;

void main() {
    vec4 worldPos = aInstanceMatrix * vec4(aPosition, 1.0);
    gl_Position = uViewProjection * worldPos;
}

Vertex Shader कोड उदाहरण

Vertex Shader विभिन्न ग्राफिक्स API में समान तर्क रखता है, लेकिन भिन्न सिंटैक्स और नामकरण परंपराएँ रखता है। आइए OpenGL ES 3.0 के लिए GLSL में और iOS तथा macOS के लिए Metal Shading Language में बुनियादी वर्टेक्स शेडर के कार्यान्वयन को देखें।

OpenGL ES 3.0 के लिए GLSL उदाहरण

#version 300 es
in vec4 position;
in vec3 normal;
in vec2 texcoord;

uniform mat4 modelViewMatrix;
uniform mat4 projectionMatrix;
uniform mat3 normalMatrix;

out vec3 vNormal;
out vec2 vTexCoord;
out vec3 vPosition;

void main() {
    vec4 mvPosition = modelViewMatrix * position;
    vPosition = mvPosition.xyz;
    vNormal = normalMatrix * normal;
    vTexCoord = texcoord;
    gl_Position = projectionMatrix * mvPosition;
}

Metal Shading Language उदाहरण

#include <metal_stdlib>
using namespace metal;

struct VertexIn {
    float3 position [[attribute(0)]];
    float3 normal   [[attribute(1)]];
};

struct VertexOut {
    float4 position [[position]];
    float3 worldNormal;
};

vertex VertexOut
vertexMain(VertexIn in [[stage_in]],
           constant float4x4& mvp [[buffer(1)]]) {
    VertexOut out;
    out.position = mvp * float4(in.position, 1.0);
    out.worldNormal = in.normal;
    return out;
}