GlActiveTexture और glBindTexture के बीच अंतर और संबंध

Question

मैं जो इकट्ठा glActiveTextureकरता हूं, उससे सक्रिय "बनावट इकाई" सेट करता है। प्रत्येक बनावट इकाई में कई बनावट लक्ष्य (आमतौर पर GL_TEXTURE_1D, 2D, 3D या CUBE_MAP) हो सकते हैं।

अगर मैं सही तरीके से समझूं, तो आपको glActiveTextureपहले टेक्सचर यूनिट (इनिशियलाइज़्ड GL_TEXTURE0) सेट करने के लिए कॉल करना होगा , और फिर आप उस टेक्सचर यूनिट को "टेक्सटाइल टारगेट" बांधेंगे?

उपलब्ध बनावट इकाइयों की संख्या प्रणाली पर निर्भर है। मैं अपनी लाइब्रेरी में 32 तक के एनम देखता हूं। मुझे लगता है कि इसका अनिवार्य रूप से मतलब है कि मेरे पास मेरे GPU की सीमा कम हो सकती है (जो मुझे लगता है कि है168) और किसी भी समय GPU मेमोरी में 32 टेक्सचर? मुझे लगता है कि एक अतिरिक्त सीमा है कि मैं अपने GPU की अधिकतम मेमोरी (माना जाता है कि 1 GB) से अधिक नहीं है।

क्या मैं बनावट के लक्ष्यों और बनावट इकाइयों के बीच संबंधों को सही ढंग से समझ रहा हूं? मान लीजिए कि मुझे 16 इकाइयाँ और 4 लक्ष्य प्रत्येक की अनुमति है, क्या इसका मतलब यह है कि 16 * 4 = 64 लक्ष्यों के लिए जगह है या यह उस तरह काम नहीं करता है?

आगे आप आमतौर पर एक बनावट लोड करना चाहते हैं। आप इसके माध्यम से कर सकते हैं glTexImage2D। जिसका पहला तर्क एक बनावट लक्ष्य है। यदि यह काम करता हैglBufferData , तो हम अनिवार्य रूप से "हैंडल" / "टेक्सचर नेम" को टेक्सटाइल टारगेट में बांधते हैं, और फिर टेक्सचर डेटा को उस टारगेट में लोड करते हैं, और इस तरह अप्रत्यक्ष रूप से उस हैंडल से जोड़ते हैं।

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

glGenerateMipmap एक लक्ष्य पर भी काम करता है ... उस लक्ष्य को अभी भी इसे सफल होने के लिए बनावट नाम के लिए बाध्य किया जाना है?

फिर जब हम उस पर एक बनावट के साथ अपनी वस्तु को खींचना चाहते हैं, तो क्या हमें दोनों को एक सक्रिय बनावट इकाई, और फिर एक बनावट लक्ष्य चुनना होगा? या क्या हम एक बनावट इकाई का चयन करते हैं, और फिर हम उस इकाई से जुड़े 4 लक्ष्यों में से किसी से डेटा हड़प सकते हैं? यह वह हिस्सा है जो वास्तव में मुझे भ्रमित कर रहा है।

Answer 1

सभी OpenGL ऑब्जेक्ट्स के बारे में

OpenGL ऑब्जेक्ट के लिए मानक मॉडल निम्नानुसार है।

वस्तुओं की अवस्था होती है। उन्हें एक के रूप में सोचो struct। तो आपके पास इस तरह परिभाषित एक वस्तु हो सकती है:

struct Object
{
    int count;
    float opacity;
    char *name;
};

ऑब्जेक्ट में कुछ निश्चित मान होते हैं और उसमें स्थिति होती है । OpenGL ऑब्जेक्ट्स में स्थिति भी होती है।

बदलती अवस्था

C / C ++ में, यदि आपके पास प्रकार है Object, तो आप इसकी स्थिति निम्नानुसार बदल देंगे: obj.count = 5;आप सीधे ऑब्जेक्ट की एक आवृत्ति का संदर्भ लेंगे, उस विशेष टुकड़े को प्राप्त करें, जिसे आप बदलना चाहते हैं, और इसमें एक मान निकाल दें।

ओपनजीएल में, आप ऐसा नहीं करते हैं।

विरासत के कारणों के लिए बेहतर अस्पष्टता छोड़ दी गई है, एक ओपन ऑब्जेक्ट की स्थिति को बदलने के लिए, आपको पहले इसे संदर्भ में बाँधना होगा। यह glBind*कॉल से कुछ के साथ किया जाता है ।

इस के बराबर C / C ++ इस प्रकार है:

Object *g_objs[MAX_LOCATIONS] = {NULL};    
void BindObject(int loc, Object *obj)
{
  g_objs[loc] = obj;
}

बनावट दिलचस्प है; वे बंधन के एक विशेष मामले का प्रतिनिधित्व करते हैं। कई glBind*कॉल में "लक्ष्य" पैरामीटर होता है। यह ओपनजीएल संदर्भ में विभिन्न स्थानों का प्रतिनिधित्व करता है जहां उस प्रकार की वस्तुओं को बाध्य किया जा सकता है। उदाहरण के लिए, आप पढ़ने ( GL_READ_FRAMEBUFFER) या लिखने के लिए ( ) के लिए एक फ़्रेमबफ़र ऑब्जेक्ट को बांध सकते हैं GL_DRAW_FRAMEBUFFER। यह प्रभावित करता है कि OpenGL बफर का उपयोग कैसे करता है। यह वही है जो locऊपर पैरामीटर का प्रतिनिधित्व करता है।

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

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

C / C ++ में, ऐसा दिखता है:

void ObjectParameteri(int loc, ObjectParameters eParam, int value)
{
  if(g_objs[loc] == NULL)
    return;

  switch(eParam)
  {
    case OBJECT_COUNT:
      g_objs[loc]->count = value;
      break;
    case OBJECT_OPACITY:
      g_objs[loc]->opacity = (float)value;
      break;
    default:
      //INVALID_ENUM error
      break;
  }
}

ध्यान दें कि यह फ़ंक्शन वर्तमान में बाध्य locमान में जो कुछ भी होता है वह कैसे सेट करता है ।

बनावट वस्तुओं के लिए, मुख्य बनावट राज्य बदलते कार्य हैं glTexParameter। बनावट की स्थिति को बदलने वाले केवल अन्य कार्य ही glTexImageकार्य और उनकी विविधताएँ हैं ( glCompressedTexImage, glCopyTexImageहाल ही में glTexStorage)। विभिन्न SubImageसंस्करण बनावट की सामग्री को बदलते हैं, लेकिन वे तकनीकी रूप से इसकी स्थिति को नहीं बदलते हैं । Imageकार्यों बनावट भंडारण आवंटन और बनावट के प्रारूप सेट; SubImageकार्यों सिर्फ पिक्सल के आसपास नकल। इसे बनावट की स्थिति नहीं माना जाता है।

मुझे दोहराने की अनुमति दें: ये एकमात्र कार्य हैं जो बनावट स्थिति को संशोधित करते हैं। glTexEnvपर्यावरण राज्य को संशोधित करता है; यह बनावट की वस्तुओं में संग्रहीत कुछ भी प्रभावित नहीं करता है।

सक्रिय बनावट

बनावट के लिए स्थिति अधिक जटिल है, फिर से विरासत के कारणों के लिए सबसे अच्छा अज्ञात है। यह वह जगह है जहाँ glActiveTextureअंदर आता है

बनावट के लिए, वहाँ सिर्फ लक्ष्य (नहीं कर रहे हैं GL_TEXTURE_1D, GL_TEXTURE_CUBE_MAP, आदि)। बनावट इकाइयाँ भी हैं । हमारे C / C ++ उदाहरण के संदर्भ में, हमारे पास यह क्या है:

Object *g_objs[MAX_OBJECTS][MAX_LOCATIONS] = {NULL};
int g_currObject = 0;

void BindObject(int loc, Object *obj)
{
  g_objs[g_currObject][loc] = obj;
}

void ActiveObject(int currObject)
{
  g_currObject = currObject;
}

ध्यान दें कि अब, हमारे पास न केवल 2 डी की सूची है Object, बल्कि हमारे पास एक वर्तमान वस्तु की अवधारणा भी है। हमारे पास वर्तमान ऑब्जेक्ट को सेट करने के लिए एक फ़ंक्शन है, हमारे पास वर्तमान ऑब्जेक्ट की अधिकतम संख्या की अवधारणा है, और हमारे सभी ऑब्जेक्ट हेरफेर फ़ंक्शन को वर्तमान ऑब्जेक्ट से चयन करने के लिए समायोजित किया गया है।

जब आप वर्तमान में सक्रिय ऑब्जेक्ट को बदलते हैं, तो आप लक्ष्य स्थानों के पूरे सेट को बदलते हैं। तो आप ऐसी चीज़ को बाँध सकते हैं जो वर्तमान ऑब्जेक्ट 0 में जाती है, वर्तमान ऑब्जेक्ट 4 पर स्विच करें, और पूरी तरह से अलग ऑब्जेक्ट को संशोधित करेगा।

बनावट की वस्तुओं के साथ यह समानता बिल्कुल सही है ... लगभग।

देखें, glActiveTextureपूर्णांक नहीं लेता है; यह एक प्रगणक लेता है । जिसका सिद्धांत में अर्थ है कि यह कुछ भी से ले सकता GL_TEXTURE0है GL_TEXTURE31। लेकिन एक बात आपको समझनी चाहिए:

यह गलत है!

वास्तविक सीमा जो glActiveTextureले जा सकती है वह नियंत्रित होती है GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS। यह एक साथ बहुपक्षीय अधिकतम संख्या है जो एक कार्यान्वयन की अनुमति देता है। ये प्रत्येक अलग-अलग shader चरणों के लिए अलग-अलग समूहों में विभाजित हैं। उदाहरण के लिए, जीएल 3.x वर्ग के हार्डवेयर पर, आपको 16 वर्टेक्स शेडर टेक्सचर, 16 फ्रैगर शैडर टेक्सचर, और 16 ज्यामिति शेडर टेक्सचर मिलते हैं। इसलिए, GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS48 होगा।

लेकिन वहाँ 48 enumerators नहीं हैं। यही कारण glActiveTextureहै कि वास्तव में enumerators नहीं ले करता है। कॉल करने का सही तरीका glActiveTextureइस प्रकार है:

glActiveTexture(GL_TEXTURE0 + i);

जहाँ i0 और के बीच एक संख्या है GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS।

प्रतिपादन

तो यह सब प्रतिपादन के साथ क्या करना है?

शेड्स का उपयोग करते समय, आप अपनी नमूना वर्दी को एक बनावट छवि इकाई ( glUniform1i(samplerLoc, i), जहां iछवि इकाई है) में सेट करते हैं। यह आपके द्वारा उपयोग की गई संख्या का प्रतिनिधित्व करता है glActiveTexture। सैंपलर प्रकार के आधार पर लक्ष्यक चुन लेगा। तो एक लक्ष्य sampler2Dसे ले जाएगा GL_TEXTURE_2D। यह एक कारण है कि नमूने के विभिन्न प्रकार होते हैं।

अब यह संदिग्ध रूप से लगता है जैसे आपके पास दो जीएलएसएल नमूने हो सकते हैं, विभिन्न प्रकार के साथ जो एक ही बनावट छवि इकाई का उपयोग करते हैं। लेकिन आप नहीं कर सकते; OpenGL इसे मना करता है और रेंडर करने का प्रयास करने पर आपको एक त्रुटि देगा।

Comments

वाह! फिर भी एक और अद्भुत जवाब - धन्यवाद निकोल! मैं विशेष रूप से एक 2 डी बनावट के बारे में उस पैराग्राफ को हमेशा एक 2 डी बनावट के रूप में पसंद करता हूं । मैं इन चीजों में से कुछ के आसपास अब एक रैपर बना रहा हूं, और मुझे यकीन नहीं था कि मुझे बदलने के लिए खुला छोड़ देना चाहिए। और के बारे में हिस्सा GL_TEXTURE0 + i- मैं यह मानने के लिए कि क्या वैध था या नहीं, यह देखने के लिए अर्थ का निरीक्षण करना था। और आखिरी पैराग्राफ - पता नहीं था कि कानूनी था या नहीं। अति उत्कृष्ट! मैं आपके सभी उत्तरों को बुकमार्क कर रहा हूं ताकि मैं उन्हें फिर से संदर्भित कर सकूं।

— मप्र

@ नाइकोल बोलस: यह वास्तव में अच्छी तरह से समझाया गया है। आपको अपनी ऑनलाइन ओपेंग्ल बुक में बनावट अध्याय में से कुछ को कॉपी करना चाहिए। मुझे लगता है कि यह इतना स्पष्ट है और अध्याय की अच्छी तारीफ करेगा।

— वेस्डेक

@ नाइकोल बोलस मैं सिर्फ ओपनजीएल सीखना शुरू कर रहा हूं और इस जवाब ने मुझे बहुत मदद की है। धन्यवाद!

— इनलाइन

हे निको, बस अपने छोटे टाइपो को इंगित करना चाहते हैं: यह GL_DRAW_FRAMEBUFFER है GL_WRITE_FRAMEBUFFER

— Defd

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

— बागर्स

Answer 2

मै उसे करने की एक कोशिश तो करूंगा ! यह सब इतना जटिल नहीं है, सिर्फ शब्दों का सवाल है, आशा है कि मैं खुद को स्पष्ट करूँगा।

---

आपके सिस्टम में उपलब्ध स्मृति के रूप में आप लगभग कई बनावट ऑब्जेक्ट बना सकते हैं । ये ऑब्जेक्ट आपके टेक्स्ट के वास्तविक डेटा (टेक्सल्स) को मापदंडों के साथ रखते हैं, जो glTexParameter द्वारा प्रदान किए गए हैं ( FAQ देखें )।

जब बनाया जा रहा है, तो आप एक आवंटित करने के लिए है बनावट लक्ष्य एक बनावट वस्तु है, जो बनावट के प्रकार का प्रतिनिधित्व करता है के लिए ( GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE, ...)।

ये दो आइटम, बनावट वस्तु और बनावट लक्ष्य बनावट डेटा का प्रतिनिधित्व करते हैं। हम बाद में उनके पास वापस आएंगे।

बनावट इकाइयाँ

अब, OpenGL बनावट इकाइयों की एक सरणी प्रदान करता है , जिसका उपयोग ड्राइंग के दौरान एक साथ किया जा सकता है। सरणी का आकार OpenGL सिस्टम पर निर्भर करता है, आपका 8 है।

ड्राइंग करते समय दी गई बनावट का उपयोग करने के लिए आप किसी टेक्सचर यूनिट के टेक्सचर ऑब्जेक्ट को बांध सकते हैं ।

एक सरल और आसान दुनिया में, दी गई बनावट के साथ आकर्षित करने के लिए, आप बनावट इकाई में एक बनावट वस्तु को बांधेंगे, और आप (छद्मकोड) करेंगे:

glTextureUnit[0] = textureObject

जैसा कि जीएल एक राज्य मशीन है, यह, अफसोस, इस तरह से काम नहीं करता है। मान लें कि हमारे textureObjectपास GL_TEXTURE_2Dबनावट लक्ष्य के लिए डेटा है , हम पिछले असाइनमेंट को निम्न रूप में व्यक्त करेंगे:

glActiveTexture(GL_TEXTURE0);                   // select slot 0 of the texture units array
glBindTexture(GL_TEXTURE_2D, textureObject);    // do the binding

ध्यान दें कि GL_TEXTURE_2Dवास्तव में उस बनावट के प्रकार पर निर्भर करता है जिसे आप बांधना चाहते हैं।

बनावट की वस्तुएँ

छद्म कोड में, बनावट डेटा या बनावट पैरामीटर सेट करने के लिए, आप उदाहरण के लिए करेंगे:

setTexData(textureObject, ...)
setTexParameter(textureObject, TEXTURE_MIN_FILTER, LINEAR)

OpenGL सीधे बनावट की वस्तुओं में हेरफेर नहीं कर सकता है, उनकी सामग्री को अपडेट / सेट करने या उनके मापदंडों को बदलने के लिए, आपको पहले उन्हें सक्रिय बनावट इकाई (जो भी यह है) से बांधना होगा। समतुल्य कोड बन जाता है:

glBindTexture(GL_TEXTURE_2D, textureObject)       // this 'installs' textureObject in texture unit
glTexImage2D(GL_TEXTURE_2D, ...)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)

shaders

शेडर्स की सभी बनावट इकाइयों तक पहुंच है, वे सक्रिय बनावट की परवाह नहीं करते हैं।

सैम्पलर वर्दी वे intमान हैं जो नमूना के लिए उपयोग करने के लिए बनावट इकाई के सूचकांक का प्रतिनिधित्व करते हैं (और उपयोग करने के लिए बनावट वस्तु नहीं )।

इसलिए आपको अपनी बनावट की वस्तुओं को उन इकाइयों से बांधना होगा जिन्हें आप उपयोग करना चाहते हैं।

नमूना का प्रकार बनावट लक्ष्य के साथ मेल खाता है जो बनावट इकाई में उपयोग किया जाता है: के Sampler2Dलिए GL_TEXTURE_2D, और इसी तरह ...

Comments

एक बात मुझे समझ में नहीं आती। मान लेते हैं कि मेरे पास कुछ बनावट है और इसका उपयोग विभिन्न बनावट इकाइयों पर कई रंगों में किया जाता है। आइए मान लें कि मैं रन टाइम पर टेक्सचर फ़िल्टरिंग को बदलना चाहता हूं। मुझे किस बनावट इकाई का उपयोग करना चाहिए? क्या मैं यूनिट 0 पर बनावट की स्थिति को बदल सकता हूं और फिर अलग-अलग इकाई पर उस बनावट का उपयोग कर सकता हूं?

— माजेकटेकरोड

@majakthecoder मेरे उत्तर में, मैं फ़िल्टरिंग को टेक्सचर ऑब्जेक्ट की एक संपत्ति के रूप में मानता हूं - जिसका मतलब है कि आप इसे विशेष रूप से टेक्सचर यूनिट में नहीं बदल सकते। आपके द्वारा लक्षित OpenGL के स्वाद के आधार पर, आप इस समस्या ( opengl.org/wiki/Sampler_Object ) को हल करने के लिए ऑब्जेक्ट सैंपल कर सकते हैं, अन्यथा, आपको एक साथ कई फ़िल्टर करने के लिए, बनावट ऑब्जेक्ट को डुप्लिकेट करना पड़ सकता है।

— रोटोग्लुप

Answer 3

कुछ पेंट प्रोसेसिंग प्लांट जैसे GPU की कल्पना करें।

कई टंकियां हैं, जो किसी न किसी पेंटिंग मशीन को डाई पहुंचाती हैं। पेंटिंग मशीन में डाई को तब ऑब्जेक्ट पर लागू किया जाता है। वे टैंक बनावट इकाइयाँ हैं

उन टैंकों को विभिन्न प्रकार की डाई से सुसज्जित किया जा सकता है। प्रत्येक प्रकार के डाई को किसी अन्य प्रकार के विलायक की आवश्यकता होती है। "विलायक" बनावट लक्ष्य है । सुविधा के लिए प्रत्येक टैंक कुछ विलायक आपूर्ति से जुड़ा हुआ है, और प्रत्येक टैंक में एक समय में केवल एक ही प्रकार के विलायक का उपयोग किया जा सकता है। तो वहाँ एक वाल्व / स्विच है TEXTURE_CUBE_MAP, TEXTURE_3D, TEXTURE_2D, TEXTURE_1D। आप एक ही समय में सभी डाई प्रकार को टैंक में भर सकते हैं, लेकिन चूंकि केवल एक प्रकार का विलायक अंदर जाता है, इसलिए यह केवल डाई के मिलान को "पतला" करेगा। तो आपके पास प्रत्येक प्रकार की बनावट बाध्य हो सकती है, लेकिन "सबसे महत्वपूर्ण" विलायक के साथ बंधन वास्तव में टैंक में जाएगा और जिस तरह की डाई के साथ मिश्रण होता है।

और फिर वहाँ डाई ही है, जो एक गोदाम से आता है और इसे "बाइंडिंग" करके टैंक में भर दिया जाता है। वह तुम्हारी बनावट है।

Comments

एक अजीब सादृश्य की तरह ... मुझे यकीन नहीं है कि यह वास्तव में कुछ भी साफ करता है। विशेष रूप से "कमजोर पड़ने" और "सबसे महत्वपूर्ण विलायक" के बारे में हिस्सा। आप कह रहे हैं कि अगर मैं 2d बनावट और 3 डी बनावट दोनों को बांधता हूं, तो मैं उनमें से केवल एक का उपयोग कर सकता हूं, या क्या? कौन सा सबसे महत्वपूर्ण माना जाएगा?

— एमपीएन

@ मर्क: खैर, मैं एक चित्रकार के संदर्भ में बोलने की कोशिश कर रहा था, जो शाब्दिक डाई (तेल आधारित और पानी आधारित है) के साथ काम करता है। वैसे भी, हाँ यदि आप बाँधते हैं और कई बनावट के लक्ष्य को सक्षम करते हैं, तो पूर्वनिर्धारण है: CUBE_MAP> 3D> TEXTURE_ARRAY> 2D> 1D।

— डेटेनवॉल्फ

साफ! मैं पूर्वता के बारे में नहीं जानता था। अब अधिक समझ में आता है कि मुझे पता है कि प्रति बनावट इकाई केवल एक बनावट लक्ष्य का उपयोग किया जा सकता है।

— एमपीएन १

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

— डेटेनवॉल्फ

@ legends2k: इसके अलावा, सोचिए कि अगर एक ही यूनिट में 2 डी और 3 डी टेक्सचर होते हैं तो क्या होगा और आपके पास एक 2 डी और 3 डी सैंपलर यूनिफॉर्म है, जिसे आप एक ही यूनिट से बांधते हैं? आप इसके साथ सभी प्रकार के अजीब ड्राइवर बग को ट्रिगर कर सकते हैं। पुराने तय किए गए फंक्शन प्रीसिडेंस मॉडल में सोच विचार करने से आपका दिमाग शांत रहता है और आपका प्रोग्राम काम करता रहता है, क्योंकि ज्यादातर ड्राइवर इसी तरह से प्रेडिक्टेबल व्यवहार करते हैं।

— डेटेनवॉल्फ

Answer 4

यदि आपकी छाया में आपको 2 बनावट से देखने की आवश्यकता है:

uniform sampler2D tex1;  
uniform sampler2D tex2;  

टेक्स 1 और टेक्स 2 के लिए उनके स्रोतों को इंगित करना आवश्यक है:

tex1 = gl.createTexture();  
gl.activeTexture(gl.TEXTURE3);  
gl.bindTexture(gl.TEXTURE_2D, tex1); 
gl.texParameteri(gl.TEXTURE_2D, ...);  
....


tex2 = gl.createTexture();  
gl.activeTexture(gl.TEXTURE7);  
gl.bindTexture(gl.TEXTURE_2D, tex2); 
gl.texParameteri(gl.TEXTURE_2D, ...);  
....  
var tex1Loc  = gl.getUniformLocation(your_shader,"tex1");  
var tex2Loc  = gl.getUniformLocation(your_shader,"tex2");

रेंडर लूप में:

gl.uniform1i(tex1Loc, 3);  
gl.uniform1i(tex2Loc, 7);  
// but you can dynamically change these values

Gl_bindtexture के साथ, ऐसा कार्य करना संभव नहीं है। दूसरी ओर प्रतिपादन के पाश में एक बाँध का एक संभावित उपयोग, मामला है जहाँ आप धारा (वीडियो, वेब कैमरा) में एक सामग्री के साथ एक बनावट खिलाते हैं:

gl.bindTexture(gl.TEXTURE_2D, tex1);  
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, video);  
// in the render loop