प्रदर्शन

में सुधार करने के लिए ओपनजीएल एसएस (आईफोन) में वेरटेक्स बफर ऑब्जेक्ट्स (वीबीओ) का उपयोग करके मैं एक घूर्णन घन प्रदर्शित करने वाले आईफोन के लिए एक साधारण एप्लीकेशन लिख रहा हूं। मैं घन के त्रिकोण खींचने और इसे घुमाने के लिए glDrawElements (openGl es) का उपयोग कर रहा हूं। मैंने देखा है कि जब मैं घन के आकार को 100 * 100 * 100 वोक्सल्स तक बढ़ाता हूं तो प्रदर्शन प्रदर्शन खराब हो जाता है (स्पष्टीकरण: मैं पूरे घन को नहीं खींचता, मैं केवल इसकी रूपरेखा (जाल) खींचता हूं। मुझे सभी त्रिकोण मिलते हैं घन पर मार्चिंग क्यूब्स एल्गोरिदम लागू करके जाल के ... अंततः मुझे 120k त्रिभुज की तरह कुछ मिलता है जो 40k शिखर तक दर्शाया जाता है) ...प्रदर्शन

घन खींचने के लिए मैं एक सरणी, सरणी रंगों और सरणी के सूचकांक यदि सूचकांक के सूचकांक। इंडेक्स सरणी कशेरुक के त्रिभुजों को खींचा जाने के लिए परिभाषित करता है। यह एक param के रूप में glDrawElements को पारित किया जाता है।

हाल ही में मैंने वर्टेक्स बफर ऑब्जेक्ट्स (वीबीओ) का उपयोग कर घन खींचने के लिए एक अलग तकनीक के बारे में लालसा किया है। मैं इसे क्रियान्वित किया है लेकिन प्रदर्शन पिछले तकनीक द्वारा फिर भी worser था

यहाँ मेरी कोड, हो सकता है कि मैं एक मूर्खतापूर्ण गलती, किसी भी सुधार के लिए सुझावों को अच्छी तरह से प्राप्त किया जाएगा :)

माध्यम से किया है किया जाता है,

http://playcontrol.net/ewing/jibberjabber/opengl_vertex_buffer_object.html http://iphonedevelopment.blogspot.com/2009/05/opengl-es-from-ground-up-table-of.html

: मैं संदर्भ के रूप में निम्न लेख में इस्तेमाल किया

//all the 7 variables down are initialized by other function at the beginning 
GLushort* meshIndices; //array of indices (ushort) 
MeshVertex* meshVertices; //array of vertices (floats) 
Color3D* meshColors;  //array of colors (floats) 

int numberOfTriangles; //number of Triangle to draw the cube 
int numberOfVertices; //number of all Vertices to draw the cube 
int numberOfIndices; //number of all Indices to draw the cube, each 3 indices define 3 vertices which define 1 triangle 
int numberOfColors; //number of colors used to draw the cube. each color is of tip Color3D 

//in this function i initializing the VBOs 
- (void) setupMeshVBOs { 

    glGenBuffers(1, &triangleVBO); 
    glBindBuffer(GL_ARRAY_BUFFER, triangleVBO); 

    const GLsizeiptr vertex_size = numberOfVertices * sizeof(MeshVertex); 
    const GLsizeiptr color_size = numberOfColors * sizeof(Color3D); 

    glBufferData(GL_ARRAY_BUFFER, vertex_size + color_size, 0, GL_STATIC_DRAW); 

    GLvoid* vbo_buffer = glMapBufferOES(GL_ARRAY_BUFFER, GL_WRITE_ONLY_OES); 
    memcpy(vbo_buffer, meshVertices, vertex_size); 

    GLbyte* temp = (GLbyte*)vbo_buffer; 
    temp += vertex_size; 
    memcpy((GLvoid*)temp, meshColors, color_size); 

    glUnmapBufferOES(GL_ARRAY_BUFFER); 

    glVertexPointer(3, GL_FLOAT, 0, (GLvoid*)((char*)NULL)); 

    glColorPointer(4, GL_FLOAT, 0, (GLvoid*)((char*)NULL+vertex_size)); 

    glGenBuffers(1, &triangleIBO); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, triangleIBO); 
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, numberOfIndices * sizeof(GLushort), meshIndices, GL_STATIC_DRAW); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); 
} 

//this function is the one which draws the VBOs 
- (void)drawView:(GLView*)view; 
{ 

    static GLfloat rot = 0.0; 


    glLoadIdentity(); 
    glTranslatef(-1.0f,-2.0f,-20.0f); 
    glRotatef(rot,1.0f,1.0f,1.0f); 
    glClearColor(0.7, 0.7, 0.7, 1.0); 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

     glBindBuffer(GL_ARRAY_BUFFER, triangleVBO); 
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, triangleIBO); 

     glEnableClientState(GL_VERTEX_ARRAY); 
     glEnableClientState(GL_COLOR_ARRAY); 

     glDrawElements(GL_TRIANGLE_STRIP, numberOfIndices, GL_UNSIGNED_SHORT, (GLvoid*)((char*)NULL)); 

     glDisableClientState(GL_VERTEX_ARRAY); 
     glDisableClientState(GL_COLOR_ARRAY); 

    static NSTimeInterval lastDrawTime; 
    if (lastDrawTime) 
    { 
     NSTimeInterval timeSinceLastDraw = [NSDate timeIntervalSinceReferenceDate] - lastDrawTime; 
     rot+=50 * timeSinceLastDraw;     
    } 
    lastDrawTime = [NSDate timeIntervalSinceReferenceDate]; 
}

स्रोत

2011-08-27 alexpov

सबसे पहले, आप 100^3 वोक्सल्स पर कहते हैं कि प्रदर्शन खराब हो जाता है। यह आश्चर्य की बात नहीं है, क्योंकि यह 1 मिलियन वोक्सल होगा। मुझे लगता है कि प्रत्येक वोक्सल एक घन है, जिसमें 12 त्रिकोण होते हैं। प्रति रेंडर कॉल 12 मिलियन त्रिकोण होगा। ये बहुत है*। यह भी ध्यान दें कि VTEs * * अधिक कुशल हो सकता है जब vertex और रंग डेटा interleaved हैं। हालांकि, आईफोन (पावरवीआर) के लिए मुझे नहीं पता कि यह मामला है या नहीं। – Arne

हां, मैंने अपने स्वयं को अच्छी तरह से समझाया नहीं है, मैंने तदनुसार प्रश्न संपादित किया है। घन 100 * 100 * 100 है लेकिन मैं पूरे घन को नहीं खींचता, मैं केवल इसकी रूपरेखा (जाल) खींचता हूं। मुझे घन पर मार्चिंग क्यूब्स एल्गोरिदम लागू करके जाल के सभी त्रिकोण मिलते हैं ... आखिर में मुझे 120k त्रिभुज की तरह कुछ मिलता है जो 40k शिखर तक प्रदर्शित होता है ... – alexpov

सबसे पहले, 100x100x100 क्यूब के मानचित्र को आकर्षित करने के लिए, आपको प्रत्येक घन को व्यक्तिगत रूप से आकर्षित नहीं करना चाहिए। यदि कहते हैं, तो पंक्ति में छह बक्से हैं, तो आपको बारह त्रिकोणों के लिए उन्हें एक लंबे cuboid के रूप में आकर्षित करना चाहिए। छः पक्षों से घिरा हुआ कोई भी घन निश्चित रूप से विचार करने की आवश्यकता नहीं है। आपको अपनी ज्यामिति गिनती को कम करने के लिए उन लोगों की रणनीतियों को लागू करना चाहिए।

जीएल अनुकूलन पर ऐप्पल की सलाह here है। सारांश संस्करण यह है कि आपको छोटे स्वीकार्य प्रकारों का उपयोग करके गठबंधन, अंतःस्थापित डेटा के साथ वीबीओ का उपयोग करना चाहिए। तो, संक्षेप में, डेटा पढ़ना एक बाधा है। दो अलग-अलग सूचियों का उपयोग करके आपकी ज्यामिति इनपुट दर को कमजोर कर दिया जा सकता है, और फ्लोट्स का उपयोग करके इसे धीमा कर दिया जा सकता है।

स्रोत

2011-08-27 18:53:48 Tommy

हैलो, मैंने आपके द्वारा सुझाए गए दस्तावेज को लाल कर दिया है और यह सभी जवाब रखता है, ... धन्यवाद :) – alexpov

प्रदर्शन

उत्तर

संबंधित मुद्दे