ओपनग्ल फ़्लिकरिंग एकाधिक ऑब्जेक्ट्स को प्रस्तुत करते समय

Question

मैं ओपनगल के लिए बहुत नया हूं और मैं वास्तव में समझ नहीं पा रहा हूं कि यहां क्या हो रहा है। मैं एकाधिक ऑब्जेक्ट्स बनाने के लिए दो वीएओ का उपयोग करने की कोशिश कर रहा हूं और उन्हें घुमाने/अनुवाद करने के लिए कस्टम मैट्रिक्स का उपयोग कर रहा हूं। जब मैं एक लोड करता हूं तो छवि ठीक होती है, लेकिन जब मैं दो लोड करता हूं तो वे दोनों झिलमिलाहट करते हैं। मेरा init यह है, जहां मेरे पास प्रत्येक बफर, vertex स्थिति, vertex सूचकांक और vertex रंगों के लिए एक अलग सरणी है।

void init() 
{ 
readFile(); 
//glEnable(GL_DEPTH); 
glEnable(GL_DEPTH_TEST); 
//make background yerpul in colour 
glClearColor(0.235, 0.194, 0.314, 1.0); 


    // Load shaders and use the resulting shader program 
    program = InitShader("aVertexShader61.glsl", "aFragShader61.glsl"); 
    glUseProgram(program); 

    // Create a vertex array object 
    glGenVertexArrays(1, &vao); 
    glBindVertexArray(vao); 

    // Create and initialize two buffer objects 
    glGenBuffers(2, buffers); 

    //one buffer for the vertexPositions and colours 
    glBindBuffer(GL_ARRAY_BUFFER, buffers[0]); 
    glBufferData(GL_ARRAY_BUFFER, numVertexPositionBytes + numVertexColourBytes,NULL, GL_STATIC_DRAW); 
    glBufferSubData(GL_ARRAY_BUFFER, 0, numVertexPositionBytes, vertexPositions); 
    glBufferSubData(GL_ARRAY_BUFFER, numVertexPositionBytes, numVertexColourBytes, vertexColours); 

    //one buffer for the indices 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]); 
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, numVertexIndexBytes,vertexIndicies, GL_STATIC_DRAW); 

    // set up vertex arrays 
    GLuint vPosition = glGetAttribLocation(program, "vPosition"); 
    glEnableVertexAttribArray(vPosition); 
    glVertexAttribPointer(vPosition, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); 

    GLuint vColor = glGetAttribLocation(program, "vColor"); 
    glEnableVertexAttribArray(vColor); 
    glVertexAttribPointer(vColor, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(numVertexPositionBytes)); 

    // Second object 

    glGenVertexArrays(1, &vao2); 
    glBindVertexArray(vao2); 

    glGenBuffers(2, buffers2); 

    //one buffer for the vertexPositions and colours 
    glBindBuffer(GL_ARRAY_BUFFER, buffers2[0]); 
    glBufferData(GL_ARRAY_BUFFER, numVertexPositionBytes + numVertexColourBytes,NULL, GL_STATIC_DRAW); 
    glBufferSubData(GL_ARRAY_BUFFER, 0, numVertexPositionBytes, vertexPositions2); 
    glBufferSubData(GL_ARRAY_BUFFER, numVertexPositionBytes, numVertexColourBytes, vertexColours2); 

    //one buffer for the indices 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers2[1]); 
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, numVertexIndexBytes,vertexIndicies2, GL_STATIC_DRAW); 

    // set up vertex arrays 
    GLuint vPosition2 = glGetAttribLocation(program, "vPosition"); 
    glEnableVertexAttribArray(vPosition2); 
    glVertexAttribPointer(vPosition2, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); 

    GLuint vColor2 = glGetAttribLocation(program, "vColor"); 
    glEnableVertexAttribArray(vColor2); 
    glVertexAttribPointer(vColor2, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(numVertexPositionBytes)); 


    glBindVertexArray(0); 
} 

यह मेरा प्रदर्शन है जो glutPostRedisplay() के साथ बुलाया जाता है; मेरे निष्क्रिय कार्य में, निष्क्रिय से कुछ भी कुछ भी नहीं किया जाता है। mStack एक बाहरी फ़ाइल

void 
    display(void) 
{ 

    //clear for first object, generate matrix and apply to object 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    mStack.loadIdentity(); 
    mStack.translatef(0,yDisplace,0); 
    mStack.rotatef(Theta[Yaxis], 0.0,1.0,0.0); 
    for (unsigned char i=0; i<NumVertices; i++){ 
     mStack.transformf(&vertexPositionsInit[i*4],&vertexPositions[i*4]); 

    } 

    //Apply to second object 
    for (unsigned char i=0; i<NumVertices; i++){ 
     mStack.transformf(&vertexPositionsInit2[i*4],&vertexPositions2[i*4]); 

    } 


    //Draw first object 
    glBindVertexArray(vao); 
    glBindBuffer(GL_ARRAY_BUFFER, buffers[0]); 
    glBufferSubData(GL_ARRAY_BUFFER, 0, numVertexPositionBytes, vertexPositions); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]); 
    //Indexing into vertices we need to use glDrawElements 
    glDrawElements(GL_TRIANGLES, NumIndicies, GL_UNSIGNED_BYTE, 0); 
    glutSwapBuffers(); 


    //Clear and draw second object 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    glutSwapBuffers(); 
    glBindVertexArray(vao2); 
    glBindBuffer(GL_ARRAY_BUFFER, buffers2[0]); 
    glBufferSubData(GL_ARRAY_BUFFER, 0, numVertexPositionBytes, vertexPositions2); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers2[1]); 
    //Indexing into vertices we need to use glDrawElements 
    glDrawElements(GL_TRIANGLES, NumIndicies, GL_UNSIGNED_BYTE, 0); 
    glutSwapBuffers(); 


} 

मैं सरल वर्टेक्स और खंड शेडर्स का उपयोग कर रहा हूं। शिखर शेडर,

in vec4 vPosition; 
in vec4 vColor; 
out vec4 color; 

void main() 
{ 
    gl_Position = vPosition; 
    color = vColor; 
} 

और टुकड़ा शेडर,

in vec4 color; 
out vec4 fColor; 

void main() 
{ 
    fColor = color; 
} 

किसी भी मदद की सराहना की है, और मैं मैट्रिक्स फ़ाइल पोस्ट कर सकते हैं यदि आवश्यकता हुई। धन्यवाद

Answer 1

ऑब्जेक्ट्स के बीच glutSwapBuffers() या glClear() पर कॉल न करें। स्वैपिंग बफर GLUT को बताने का एक तरीका है "ठीक है, मैं इस फ्रेम के साथ कर रहा हूं, चलो अगले के साथ शुरू करें।"

आमतौर पर

आप, कोड है कि प्रत्येक फ्रेम कोड है कि प्रत्येक वस्तु renders से (glClear() के लिए कॉल और glutSwapBuffers()) की तरह सेट और पूरा करता है बाहर विभाजित करने के लिए चाहते हैं क्योंकि ओपन मूल रूप से है वैश्विक चर का एक विशाल बॉक्स और यह है छोटे टुकड़ों में अपनी विधियों को तोड़ने के बिना अच्छा ओपनजीएल कोड लिखना मुश्किल है।