ओपनजीएल में एकाधिक व्यूपोर्ट्स का उपयोग कैसे करें?

Question

मुझे ओपनजीएल में दो अलग-अलग व्यूपोर्ट्स में एक ही ऑब्जेक्ट दिखाने की ज़रूरत है, उदाहरण के लिए, ऑर्टोग्राफिक प्रक्षेपण का उपयोग करके और दूसरा परिप्रेक्ष्य का उपयोग कर। ऐसा करने के लिए, क्या मुझे प्रत्येक कॉल के बाद glViewport() पर ऑब्जेक्ट को फिर से खींचना होगा?

Answer 1

Nehe इस पर एक अच्छा ट्यूटोरियल है कि यह कैसे करें, और उनकी साइट आम तौर पर ओपनजीएल सवालों के लिए एक अच्छा संसाधन है।

Answer 2

हाँ,

और आप भी दो विचारों के बीच एक साफ जुदाई के लिए अगर वे एक ही विंडो में हैं कैंची सेटिंग में बदलाव करना चाहिए।

Answer 3

// normal mode 
    if(!divided_view_port) 
    glViewport(0, 0, w, h); 
else 
{ 
    // right bottom 
    glViewport(w/2, h/2, w, h); 
    glLoadIdentity(); 
    gluLookAt(5.0f, 5.0f, 5.0f, 
       0.0f, 0.0f, 0.0f, 
       0.0f, 1.0f, 0.0f); 

    display(); 

    // left bottom 
    glViewport(0, h/2, w/2, h); 
    glLoadIdentity(); 
    gluLookAt (5.0f, 0.0f, 0.0f, 
       0.0f, 0.0f, 0.0f, 
       0.0f, 1.0f, 0.0f); 

    display(); 

    // top right 
    glViewport(w/2, 0, w, h/2); 
    glLoadIdentity(); 
    gluLookAt(0.0f, 0.0f, 5.0f, 
       0.0f, 0.0f, 0.0f, 
       0.0f, 1.0f, 0.0f); 

    display(); 

    // top left 
    glViewport(0, 0, w/2, h/2); 
    glLoadIdentity(); 
    gluLookAt(0.0f, 5.0f, 0.0f, 
       0.0f, 0.0f, 0.0f, 
       0.0f, 1.0f, 0.0f); 

    display(); 
} 
glMatrixMode(GL_PROJECTION); 
glLoadIdentity(); 

if (w <= h) 
    glOrtho(-2.0, 2.0, 
      -2.0 * (GLfloat) h/(GLfloat) w, 2.0 * (GLfloat) h/(GLfloat) w, 
    -10.0, 100.0); 
else 
    glOrtho(-2.0 * (GLfloat) w/(GLfloat) h, 2.0 * (GLfloat) w/(GLfloat) h, 
    -2.0, 2.0, 
    -10.0, 100.0); 

glMatrixMode(GL_MODELVIEW); 

Answer 4

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

वहाँ भी है कि NeHe के ट्यूटोरियल आप के महत्व को नहीं बताया ओपन के साथ दो आदेशों है:

wglCreateContext - जो एक खिड़की डिवाइस संदर्भ डीसी लेता है, किसी भी खिड़की से प्राप्त किया जा सकता है - चाहे वह एक उपयोगकर्ता नियंत्रण है, एक विंडोज़ फॉर्म, एक जीएल विंडो, या एक और एप्लीकेशन विंडो (नोटपैड की तरह)। यह एक ओपनजीएल डिवाइस संदर्भ बनाता है - जिसे आप बाद में उपयोग करते हैं -

wglMakeCurrent - जो दो पैरामीटर लेता है, डिवाइस कॉन्टेक्स्ट जिसमें आप काम कर रहे हैं (विंडोज़ के लिए पारित पैरामीटर WglCreateContext में डिवाइस संदर्भ) - और संसाधन संदर्भ जो लौटाता है।

केवल इन दो चीजों का इस्तेमाल - यहाँ मेरी सलाह है:

NeHe के ट्यूटोरियल एक समाधान है कि मौजूदा खिड़की केवल और क्षेत्रों ड्राइंग के लिए स्क्रीन का लाभ उठाता है प्रदान करता है। यहां ट्यूटोरियल है: http://nehe.gamedev.net/tutorial/multiple_viewports/20002/

लीवरेजिंग glViewport आपको प्रत्येक अपडेट पर फिर से आकर्षित करने की आवश्यकता होगी।

यह एक तरीका है।

लेकिन वहाँ एक और है - कम रेखांकन और प्रोसेसर गहन विधि:

एक उपयोगकर्ता नियंत्रण का लाभ उठाकर प्रत्येक दृश्य के लिए एक खिड़की बनाएँ।

प्रत्येक विंडो में इसका स्वयं का एचडब्ल्यूएनडी है।

डीसी प्राप्त करें, wglcreatecontext को संसाधित करें, और उसके बाद, टाइमर पर (मेरा 30 फ्रेम एक सेकेंड है), यदि आप राज्य परिवर्तन का पता लगाते हैं, तो उस दृश्य के लिए wglMakeCurrent का चयन करें और फिर से करें। अन्यथा, अनुभाग को पूरी तरह से छोड़ दें।

यह मूल्यवान प्रसंस्करण शक्ति को संरक्षित करता है, और कोड को मैन्युअल रूप से विंडो और व्यूपोर्ट गणनाओं को प्रबंधित करने से भी कम करता है।

Answer 5

मिनिमल runnable उदाहरण

this answer की तरह, लेकिन अधिक प्रत्यक्ष और compilable।आउटपुट:

कोड:

#include <stdlib.h> 

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

static int width; 
static int height; 

static void display(void) { 
    glClear(GL_COLOR_BUFFER_BIT); 
    glColor3f(1.0f, 0.0f, 0.0f); 

    glViewport(0, 0, width/2, height/2); 
    glLoadIdentity(); 
    gluLookAt(0.0, 0.0, -3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); 
    glutWireTeapot(1); 

    glViewport(width/2, 0, width/2, height/2); 
    glLoadIdentity(); 
    gluLookAt(0.0, 0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); 
    glutWireTeapot(1); 

    glViewport(0, height/2, width/2, height/2); 
    glLoadIdentity(); 
    gluLookAt(0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0); 
    glutWireTeapot(1); 

    glViewport(width/2, height/2, width/2, height/2); 
    glLoadIdentity(); 
    gluLookAt(0.0, -3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0); 
    glutWireTeapot(1); 

    glFlush(); 
} 

static void reshape(int w, int h) { 
    width = w; 
    height = h; 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    glFrustum(-1.0, 1.0, -1.0, 1.0, 1.5, 20.0); 
    glMatrixMode(GL_MODELVIEW); 
} 

int main(int argc, char** argv) { 
    glutInit(&argc, argv); 
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); 
    glutInitWindowSize(500, 500); 
    glutInitWindowPosition(100, 100); 
    glutCreateWindow(argv[0]); 
    glClearColor(0.0, 0.0, 0.0, 0.0); 
    glShadeModel(GL_FLAT); 
    glutDisplayFunc(display); 
    glutReshapeFunc(reshape); 
    glutMainLoop(); 
    return EXIT_SUCCESS; 
} 

संकलित साथ:

gcc -lGL -lGLU -lglut main.c 

ओपन पर परीक्षण किया गया NVIDIA 352.63, उबंटू 15.10 4.5.0।

कार्यसूची: मुझे लगता है कि आधुनिक ओपन 4 में तुम सिर्फ बनावट के लिए प्रस्तुत करना चाहिए, और फिर स्क्रीन पर orthogonaly उन बनावट जगह, एक प्रारंभिक बिंदु के रूप में देखते: http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-14-render-to-texture/

Answer 6

जीएल 4 में आप कई लोगों के लिए प्रदान कर सकते हैं एक प्रतिपादन पास में व्यूपोर्ट्स। ARB_viewport_array और संबंधित अवधारणाएं देखें।