क्यों नहीं 3.3 या 4.2 ओपन के glDrawArrays() कोर के तहत GL_INVALID_OPERATION के साथ विफल प्रोफाइल 3.2 करता है, लेकिन?

Question

मुझे लगता है कि दोषरहित एक स्पष्ट अनुरोध किया ओपन कोर संदर्भ 3.2 के साथ काम करता है जब ओपन संदर्भ है (स्वतः/परोक्ष प्राप्त) 4.2 लेकिन लगातार विफल रहता है (GL_INVALID_OPERATION) glDrawArrays बुला ओपन प्रतिपादन कोड है। (Shaders हमेशा 150 दोनों ही मामलों में #version की तैयारी में हैं लेकिन यह है कि मुझे लगता है यहाँ बिंदु के पास है।)

चश्मा के अनुसार, वहाँ केवल दो उदाहरण हैं जब glDrawArrays() GL_INVALID_OPERATION के साथ विफल:

• "एक गैर शून्य बफर ऑब्जेक्ट नाम एक सक्षम सरणी के लिए बाध्य है और बफर वस्तु के डेटा की दुकान वर्तमान में मैप किया गया है" - मैं इस बिंदु पर किसी भी बफर मानचित्रण नहीं कर रहा हूँ

• "अगर एक ज्यामिति शेडर सक्रिय है और मोड के साथ असंगत है [...] "- नहीं, कोई ज्यामिति नहीं है अभी के रूप में शेडर्स।

इसके अलावा:

1. मैं सत्यापित किया है & की दोबारा जांच कर कि यह केवल glDrawArrays है() में नाकाम रहने के कॉल। इसके अलावा दोबारा जांच कि सभी तर्क glDrawArrays() के लिए पारित दोनों जीएल संस्करणों, बफर बाइंडिंग भी के तहत समान हैं।

2. यह तब होता है भर में 3 अलग NVIDIA GPUs और 2 अलग OSes (Win7 और OSX, दोनों 64-बिट - ज़ाहिर है, OSX में हम केवल 3.2 संदर्भ है, कोई 4.2 वैसे भी)।

3. यह एक एकीकृत "इंटेल HD" GPU के साथ ऐसा नहीं होता है लेकिन यह है कि एक के लिए, मैं सिर्फ एक स्वत: निहित 3.3 संदर्भ पाने (स्पष्ट रूप से GLFW के माध्यम से इस GPU के साथ एक 3.2 कोर प्रोफ़ाइल के लिए मजबूर करने की कोशिश कर रहा यहाँ खिड़की निर्माण में विफल रहता है, लेकिन कि एक बिल्कुल अलग मुद्दा ...)

क्या इसके लायक है के लिए, यहाँ प्रासंगिक दिनचर्या पाश प्रस्तुत करना से कुछ अंश है, Golang में:

func (me *TMesh) render() { 
    curMesh = me 
    curTechnique.OnRenderMesh() 
    gl.BindBuffer(gl.ARRAY_BUFFER, me.glVertBuf) 
    if me.glElemBuf > 0 { 
     gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, me.glElemBuf) 
     gl.VertexAttribPointer(curProg.AttrLocs["aPos"], 3, gl.FLOAT, gl.FALSE, 0, gl.Pointer(nil)) 
     gl.DrawElements(me.glMode, me.glNumIndices, gl.UNSIGNED_INT, gl.Pointer(nil)) 
     gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0) 
    } else { 
     gl.VertexAttribPointer(curProg.AttrLocs["aPos"], 3, gl.FLOAT, gl.FALSE, 0, gl.Pointer(nil)) 
     /* BOOM! */ 
     gl.DrawArrays(me.glMode, 0, me.glNumVerts) 
    } 
    gl.BindBuffer(gl.ARRAY_BUFFER, 0) 
} 

तो निश्चित रूप से यह एक बड़ा का हिस्सा है रेंडर-लूप, हालांकि पूरे "* टीएमश" construc अब के लिए tion सिर्फ दो उदाहरण हैं, एक एक सरल घन और अन्य एक साधारण पिरामिड है। क्या मायने रखता है कि संपूर्ण ड्राइंग लूप दोषपूर्ण ढंग से काम करता है जब जीएल को 3.3 और 4.2 दोनों के तहत त्रुटियों के लिए पूछताछ की जाती है, फिर भी एक स्पष्ट 3.2 कोर प्रोफाइल के साथ 3 एनवीडिया जीपीयू पर एक त्रुटि कोड के साथ विफल रहता है कि spec के अनुसार केवल इसमें शामिल किया जाता है दो विशिष्ट स्थितियों, जिनमें से कोई भी मैं कह सकता हूं यहां आवेदन करें।

क्या गलत यहाँ हो सकता है? क्या आपने कभी इसमें भाग लिया है? कोई विचार जो मुझे याद आ रहा है?

Answer 1

मैं एक जंगली अनुमान है।

जैसा कि मैं इसे समझता हूं, सभी ओपनजीएल कॉल एक ही थ्रेड पर होने चाहिए। यह प्रतिबंध goroutines के साथ अच्छी तरह से मिश्रण नहीं करता है, क्योंकि एक ही goroutine विभिन्न निष्पादन में विभिन्न बिंदुओं पर अपने निष्पादन में चला सकते हैं।

इस समस्या को हल करने के लिए, आपको ओपनजीएल शुरू करने से पहले, अपने मुख्य गोरौटाइन (या जो भी गोरौटाइन ओपनजीएल कॉल कर रहा है) को लॉन्च करने की आवश्यकता है, जैसे ही यह शुरू होता है।

import "runtime" 

func main() { 
    runtime.LockOSThread() 

    ... 
} 

असंगत परिणामों को देखने का कारण कार्यान्वयन मतभेदों द्वारा समझाया जा सकता है।

Answer 2

यह सिर्फDrawArrays नहीं है, मैं यहाँ गलत था। किसी भी तरह को कॉल करने का मेरा तरीका glVertexAttribPointer यहां समस्या है: सख्त कोर प्रोफ़ाइल, चाहे 3.2 या 4.2 ... आगे की जांच करेगी। एक 4.2 गैर सख्त संदर्भ में, कोई समस्या नहीं है।