2009-02-25 28 views
6

ओपनजीएल का उपयोग करके मैं अपने परिसर का एक प्राचीन मानचित्र आकर्षित करने का प्रयास कर रहा हूं।ज़ूमिंग, पैनिंग और घूर्णन कैसे काम करता है?

क्या कोई मुझे बता सकता है कि पैनिंग, ज़ूमिंग और घूर्णन आमतौर पर कैसे लागू किया जाता है?

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

पैनिंग के लिए, क्या यह मेरे व्यूपोर्ट के एक्स/वाई मानों को स्थानांतरित करता है और ज़ूमिंग के लिए यह कुछ व्यय से मेरे व्यूपोर्ट को बढ़ाता/घटाता है? घूर्णन के लिए क्या?

घूर्णन के लिए, क्या मुझे अपने कैंपस मानचित्र का प्रतिनिधित्व करने वाली प्रत्येक पॉलीलाइन के लिए एफ़िन ट्रांसफॉर्म करना है? क्या यह एक सभ्य आकार के मानचित्र पर फ्लाई पर महंगा नहीं होगा?

या, क्या व्यूपोर्ट वही छोड़ दिया गया है और किसी अन्य तरीके से पैनिंग/ज़ूमिंग/रोटेशन किया जाता है?


उदाहरण के लिए, अगर आप इस link के पास जाओ तुम उसे पैनिंग और वास्तव में जूम करने के लिए कैसे मैं ऊपर है, व्यूपोर्ट को संशोधित करके वर्णन देखेंगे।

क्या यह सही नहीं है?

उत्तर

7

वे दृश्य खींचने से पहले glTranslate, glRotate आदेश (जो कैमरा स्थिति और अभिविन्यास का प्रतिनिधित्व करते हैं) की एक श्रृंखला को लागू करके हासिल किए जाते हैं। (तकनीकी रूप से, आप पूरे दृश्य को घुमा रहे हैं!)

ग्लू लुक जैसे उपयोगिता कार्य हैं जो इस बारे में कुछ विवरण बताते हैं।

चीजों को सरल बनाने के लिए, मान लीजिए कि आपके कैमरे का प्रतिनिधित्व करने वाले दो वैक्टर हैं: स्थिति और दिशा।

gluLook यह स्थिति, गंतव्य और ऊपर वेक्टर लेता है।

यदि आप वेक्टर कक्षा लागू करते हैं, तो destinaion = position + direction आपको गंतव्य स्थान देना चाहिए।

फिर तो चीजों को सरल बनाने के लिए, आप वेक्टर मान हमेशा हो सकता है (0,1,0)

, अपने दृश्य में कुछ भी प्रतिपादन से पहले, पहचान मैट्रिक्स लोड और फोन gluLookAt

glMatrixMode(GL_MODELVIEW); 
glLoadIdentity(); 
gluLookAt(source.x, source.y, source.z, destination.x, destination.y, destination.z, 0, 1, 0); 

फिर अपनी ऑब्जेक्ट्स ड्राइंग करना शुरू करें

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

एक समस्या यह है कि, यदि आपके पास केवल दिशा वेक्टर "आगे" है, तो आप इसे कैसे स्थानांतरित करते हैं? दाएं और बाएं कहां है?

इस मामले में मेरा दृष्टिकोण केवल "दिशा" और (0,1,0) के क्रॉस उत्पाद को लेना है।

अब आप बाईं ओर और की तरह कुछ का उपयोग कर सही करने के लिए कैमरा ले जा सकते हैं:

position = position + right * amount; //amount < 0 moves to the left 

आप आगे "दिशा वेक्टर" का उपयोग कर स्थानांतरित कर सकते हैं, लेकिन IMO यह एक क्षैतिज विमान को आंदोलन को प्रतिबंधित करने के लिए बेहतर है है, तो आगे वेक्टर उसी तरह हम सही वेक्टर मिला मिलती है:

forward = cross(up, right) 

ईमानदारी से कहूं तो, यह एक hackish दृष्टिकोण का कुछ हद तक है।

उचित दृष्टिकोण कैमरे के "अभिविन्यास" का प्रतिनिधित्व करने के लिए एक और अधिक "परिष्कृत" डेटा संरचना का उपयोग करना है, न केवल आगे की दिशा। हालांकि, चूंकि आप अभी शुरू कर रहे हैं, एक समय में चीजों को एक कदम उठाना अच्छा होता है।

+2

मुझे यह जोड़ने दें कि किसी भी समय "व्यूपोर्ट" (जैसा कि glViewport के माध्यम से सेट किया गया है) इस प्रक्रिया में आता है। व्यूपोर्ट निर्धारित करता है कि आप अपनी खिड़की के किस क्षेत्र को प्रस्तुत करेंगे (यह वास्तव में सच नहीं है, लेकिन इसके बारे में इस बारे में सोचें) और आम तौर पर पूरी खिड़की का विस्तार करेगा। – Thomas

1

आम तौर पर जब भी आप ओपनएल के भीतर 3 डी स्पेस में किसी भी बिंदु का संदर्भ देते हैं तो तीन चरण लागू होते हैं।

एक स्थानीय बिंदु

  • स्थानीय देखते हुए -> विश्व रूपांतरण
  • दुनिया -> कैमरा रूपांतरण
  • कैमरा -।> स्क्रीन रूपांतरण (आमतौर पर एक प्रक्षेपण आप परिप्रेक्ष्य या ओर्थोगोनल उपयोग कर रहे हैं पर निर्भर करता है)

इनमें से प्रत्येक परिवर्तन आपके 3 डी बिंदु ले रहा है, और एक मैट्रिक्स द्वारा गुणा कर रहा है।

जब आप कैमरे को घुमा रहे हैं, तो यह आमतौर पर दुनिया को बदल रहा है -> कैमरा आपके घूर्णन/पैन/ज़ूम एफ़िन रूपांतरण द्वारा ट्रांसफॉर्म मैट्रिक्स को गुणा करके बदल रहा है। चूंकि आपके सभी बिंदु प्रत्येक फ्रेम को फिर से प्रस्तुत किए जाते हैं, इसलिए नए मैट्रिक्स आपके बिंदुओं पर लागू होते हैं, और यह एक घूर्णन की उपस्थिति देता है।

4

मॉडल-व्यू मैट्रिक्स रूपांतरण कार्यों का उपयोग करके इन सभी "क्रियाओं" को हासिल किया जा सकता है। आपको glTranslatef (पैनिंग), glScalef (ज़ूम), glRotatef (रोटेशन) के बारे में पढ़ना चाहिए। आपको ओपनजीएल के बारे में कुछ बुनियादी ट्यूटोरियल पढ़ने की भी आवश्यकता होनी चाहिए, आपको this link उपयोगी मिल सकता है।