ओपनग्ल

Question

का उपयोग करके सर्पिल कैसे आकर्षित करें मैं जानना चाहता हूं कि सर्पिल कैसे आकर्षित करें।

void RenderScene(void) 
{ 
    glClear(GL_COLOR_BUFFER_BIT); 
    GLfloat x,y,z = -50,angle; 
    glBegin(GL_POINTS); 

    for(angle = 0; angle < 360; angle += 1) 
    { 
     x = 50 * cos(angle); 
     y = 50 * sin(angle); 
     glVertex3f(x,y,z); 
     z+=1; 
    } 
    glEnd(); 
    glutSwapBuffers(); 
} 

मैं जेड शर्तें भी शामिल नहीं है, तो मैं एक आदर्श चक्र प्राप्त लेकिन जब मैं जेड में शामिल हैं, तो मैं 3 डॉट्स यह है कि मिल:

मैं इस कोड लिखा था। क्या हो सकता है?

मैं व्यूपोर्ट glviewport का उपयोग कर (0,0, डब्ल्यू, ज)

जेड शामिल करने के लिए मैं जेड दिशा में व्यूपोर्ट सेट के लिए कुछ भी करना चाहिए सेट?

Answer 1

आप अंक देखते हैं क्योंकि आप glBegin(GL_POINTS) के साथ अंक खींच रहे हैं। इसे glBegin(GL_LINE_STRIP) द्वारा प्रतिस्थापित करने का प्रयास करें।

नोट: जब आपने सर्कल देखा तो आपने केवल अंक खींचा, लेकिन एक कनेक्टेड सर्कल के रूप में दिखाई देने के लिए पर्याप्त करीब खींचा।

इसके अलावा, आपने श्रेणी z = [-50, 310] में मानों को स्वीकार करने के लिए गहराई बफर सेट नहीं किया हो सकता है। इन तर्कों को zNear और zFar अपने gluPerspective, glOrtho() या glFrustum() कॉल में क्लिपिंग विमानों के रूप में प्रदान किया जाना चाहिए।

नोट: यह समझाएगा कि ज़ेड वैल्यू के साथ आप केवल कुछ बिंदु क्यों देखते हैं: अन्य बिंदु फिसल गए हैं क्योंकि वे जेड-बफर रेंज के बाहर हैं।

अद्यतन करने के बाद आप अपने कोड से पता चला है:

glOrtho(-100*aspectratio,100*aspectratio,-100,100,1,-1); केवल में [-1, 1] रेंज है, जिसके कारण z = -1, z = 0 और z = 1 साथ केवल तीन अंक हो जाएगा z के मूल्यों की अनुमति होगी खींचा (इस प्रकार 3 अंक)।

अंत में, आप शायद घुमावदार धुरी की दिशा में सीधे देखकर सर्पिल को शीर्ष से देख रहे हैं। यदि आप परिप्रेक्ष्य प्रक्षेपण (लेकिन एक आइसोमेट्रिक एक) का उपयोग नहीं कर रहे हैं, तो सर्पिल अभी भी एक सर्कल के रूप में दिखाई देगा। आप gluLookAt() के साथ अपना विचार बदलना चाहेंगे।

परिपेक्ष्य की स्थापना के उदाहरण

निम्नलिखित code NeHe द्वारा उत्कृष्ट ओपन ट्यूटोरियल से लिया जाता है: अपने draw loop में

glViewport(0, 0, width, height); 
glMatrixMode(GL_PROJECTION);      // Select The Projection Matrix 
glLoadIdentity();       // Reset The Projection Matrix 

// Calculate The Aspect Ratio Of The Window 
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f); 

glMatrixMode(GL_MODELVIEW);      // Select The Modelview Matrix 
glLoadIdentity();       // Reset The Modelview Matrix 

फिर, कुछ इस तरह दिखेगा:

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  // Clear The Screen And The Depth Buffer 
glLoadIdentity(); 
glTranslatef(-1.5f,0.0f,-6.0f);     // Move Left 1.5 Units And Into The Screen 6.0 
glBegin(GL_TRIANGLES);      // Drawing Using Triangles 
    glVertex3f(0.0f, 1.0f, 0.0f);    // Top 
    glVertex3f(-1.0f,-1.0f, 0.0f);    // Bottom Left 
    glVertex3f(1.0f,-1.0f, 0.0f);    // Bottom Right 
glEnd();  

बेशक, आपको इस उदाहरण कोड को अपनी आवश्यकताओं को बदलना चाहिए।

Answer 2

catchmeifyoutry एक पूरी तरह से सक्षम विधि प्रदान करता है, लेकिन एक स्थानिक रूप से सटीक 3 डी सर्पिल नहीं खींचता है, क्योंकि किसी GL_LINE आदिम प्रकार का उपयोग करके किसी भी रेंडर कॉल को निश्चित पिक्सेल चौड़ाई में रास्टरराइज किया जाएगा। इसका मतलब यह है कि जब आप अपना परिप्रेक्ष्य/दृश्य बदलते हैं, तो रेखाएं चौड़ाई नहीं बदलेगी। इसे पूरा करने के लिए, 3 डी ज्यामिति बनाने के लिए GL_LINE_STRIP_ADJACENCY के संयोजन में एक ज्यामिति शेडर का उपयोग करें जिसे किसी भी अन्य 3 डी ज्यामिति की तरह rasterized किया जा सकता है।(यह आवश्यक है कि आप पोस्ट फिक्स्ड-फ़ंक्शन पाइपलाइन का उपयोग करें)

मैंने आपको पहले पकड़ने की विधि को आजमाने की सलाह दी है क्योंकि यह बहुत आसान होगा। यदि आप संतुष्ट नहीं हैं, तो मैंने वर्णित विधि को आजमाएं।

http://prideout.net/blog/?tag=opengl-tron

Answer 3

यहाँ सी में मेरी सर्पिल समारोह अंक एक सूची है जो आसानी से ओपन से खींचा जा सकता है में सहेजे जाते हैं है (उदाहरण के लिए GL_LINES के साथ इस सूची में आसन्न अंक कनेक्ट): आप मार्गदर्शन के रूप में निम्नलिखित पोस्ट उपयोग कर सकते हैं ।

• cx, cy ... सर्पिल केंद्र x और y
• आर ... अधिकतम सर्पिल त्रिज्या

• NUM_SEGMENTS ... खंडों की संख्या का समन्वय करता सर्पिल होगा

  SOME_LIST* UniformSpiralPoints(float cx, float cy, float r, int num_segments) 
  { 
  SOME_LIST *sl = newSomeList(); 
  int i; 
  
  for(i = 0; i < num_segments; i++) 
  { 
  float theta = 2.0f * 3.1415926f * i/num_segments; //the current angle 
  
  float x = (r/num_segments)*i * cosf(theta); //the x component 
  float y = (r/num_segments)*i * sinf(theta); //the y component 
  
  //add (x + cx, y + cy) to list sl 
  
  } 
  return sl; 
  } 
  

r = 1, NUM_SEGMENTS साथ उदाहरण चित्र = 1024:

पीएस कॉस (डबल) और कॉस्फ (फ्लोट) का उपयोग करने में अंतर है। आप एक डबल फंक्शन कॉस के लिए एक फ्लोट वैरिएबल का उपयोग करते हैं।