c - स्क्रीन पर रंग दोहरे रंग की एक 2 डी सरणी को आकर्षित करने का सबसे तेज़ तरीका क्या है?




linux opengl (4)

लक्ष्य भाषा सी / सी ++ है और कार्यक्रम केवल लिनक्स पर काम करने के लिए है, लेकिन प्लेटफॉर्म स्वतंत्र समाधान पसंदीदा रूप से पसंद किया गया है। मैं Xorg, XVideo और ओपनजीएल चलाता हूं।

इंटेल ग्राफिक्स के साथ इंटेल कोर 2 डुओ पर 1024x768 पर कितने एफपीएस की उम्मीद कर सकता हूं? (केवल आरेखण की गणना, रैम में तैयार होने के लिए एरे को ध्यान में रखें; कोई सटीक पूर्वानुमान न होना आवश्यक है)


1024x768 पर कितने एफपीएस की उम्मीद कर सकता हूं?

उस प्रश्न का उत्तर इतने सारे कारकों पर निर्भर करता है कि यह बताना संभव नहीं है


अगर आप स्क्रीन पर पिक्सेल डंप करने की कोशिश कर रहे हैं, तो आप शायद एसडीएल की 'सतह' सुविधा का उपयोग करना चाहते हैं सबसे बड़ा प्रदर्शन के लिए, आउटपुट की सतह के समान लेआउट में इनपुट डेटा की व्यवस्था करने का प्रयास करें। यदि संभव हो तो, एक बार में सतह पर पिक्सल को सेट करने से स्पष्ट रूप से चलाएं।

एसडीएल एक हार्डवेयर इंटरफ़ेस नहीं है, बल्कि एक पोर्टेबिलिटी लेयर है, जो डायरेक्टएक्स, ओपनजीएल, डायरेक्टएफबी, और एक्सलिब समेत कई डिस्प्ले परतों के ऊपर अच्छी तरह से काम करता है, इसलिए आपको बहुत अच्छी पोर्टेबिलिटी मिलती है, और इसकी एक बहुत ही पतली परत उन प्रौद्योगिकियों के शीर्ष पर, ताकि आप उन लोगों के शीर्ष पर बहुत कम प्रदर्शन ऊपरी भाग लेंगे


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

यहाँ कुछ उदाहरण कोड है, आशा है कि आप इसका उपयोग कर सकते हैं।

#include <GL/glut.h>
#include <GL/glut.h>

#define WIDTH 1024
#define HEIGHT 768

unsigned char texture[WIDTH][HEIGHT][3];             

void renderScene() {    

    // render the texture here

    glEnable (GL_TEXTURE_2D);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexImage2D (
        GL_TEXTURE_2D,
        0,
        GL_RGB,
        WIDTH,
        HEIGHT,
        0,
        GL_RGB,
        GL_UNSIGNED_BYTE,
        &texture[0][0][0]
    );

    glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f); glVertex2f(-1.0, -1.0);
        glTexCoord2f(1.0f, 0.0f); glVertex2f( 1.0, -1.0);
        glTexCoord2f(1.0f, 1.0f); glVertex2f( 1.0,  1.0);
        glTexCoord2f(0.0f, 1.0f); glVertex2f(-1.0,  1.0);
    glEnd();

    glFlush();
    glutSwapBuffers();
}

int main(int argc, char **argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

    glutInitWindowPosition(100, 100);
    glutInitWindowSize(WIDTH, HEIGHT);
    glutCreateWindow(" ");

    glutDisplayFunc(renderScene);

    glutMainLoop();

    return 0;
}

रंग दोहरे रंग की एक 2 डी सरणी को आकर्षित करने का सबसे तेज़ तरीका:

  1. फ्लोट का प्रयोग करें (बाइट नहीं , डबल नहीं ) संग्रहण। प्रत्येक त्रयी में 3 फ्लोट्स 0.0 से 1.0 प्रत्येक होते हैं। यह प्रारूप GPUs द्वारा सबसे बेहतर कार्यान्वित किया गया है (लेकिन जब आपको रंग की आवश्यकता नहीं है तो GL_LUMINANCE भंडारण का उपयोग करें - बहुत तेज़!)
  2. glTexImage2D साथ एक बनावट में सरणी अपलोड करें
  3. सुनिश्चित करें कि GL_TEXTURE_MIN_FILTER बनावट पैरामीटर GL_TEXTURE_MIN_FILTER पर सेट है
  4. उपयुक्त क्वाड के लिए बनावट को मैप करें।

यह विधि glDrawPixels (जो कुछ कारणों से बुरी तरह से लागू की जाती है) की तुलना में थोड़ा अधिक तेज है और प्लेटफॉर्म की देशी ब्लूटिंग का उपयोग करने से बहुत तेज है।

इसके अलावा, यह आपको चरण 2 के बिना चरण 4 के बार-बार करने का विकल्प देता है, जब आपका पिक्समैप नहीं बदलता है, जो निश्चित रूप से बहुत तेज है।

लाइब्रेरी जो केवल धीमी देशी ब्लेटिंग प्रदान करते हैं इसमें शामिल हैं:

  • विंडोज़ जीडीआई
  • एसडीएल X11 पर (विंडोज़ पर यह एक तेज ओपन बैकएंड प्रदान करता है जब एचडब्लू-सीएफएएफईईएसी का इस्तेमाल करते हैं)
  • क्यूटी

इंटेल ग्राफिक्स के साथ इंटेल कोर 2 डुओ पर एक 1024x768 बनावट ड्राइंग, एफपीएस के रूप में आप उम्मीद कर सकते हैं: लगभग 60 एफपीएस यदि बनावट प्रत्येक फ्रेम और> 100 एफपीएस में परिवर्तन करता है यदि यह नहीं है

लेकिन बस खुद करो और देखें;)







xorg