👓 🕠 🎑 हम रूबिक का क्यूब एमुलेटर लिखते हैं 👩🏻‍🤝‍👨🏾 🐘 👎🏽

OpenGL एक प्लेटफ़ॉर्म-स्वतंत्र विनिर्देश है जो दो-आयामी और तीन-आयामी ग्राफिक्स का उपयोग करके कंप्यूटर अनुप्रयोगों को बनाने के लिए एक प्रोग्रामिंग इंटरफ़ेस का वर्णन करता है।
इस लेख में, मैं वर्णन करूंगा कि आप ओपनगेल पर रूबिक क्यूब एमुलेटर कैसे बना सकते हैं।

क्यूब 3 डी में होगा और माउस के साथ इसे घुमाने के लिए संभव होगा, और आप तीर पर क्लिक करके चेहरे को फ्लिप कर सकते हैं। इसके अलावा, तीर दर्शक के सबसे करीब किनारे पर दिखाई देते हैं।

मैं रुबिक के क्यूब एम्यूलेटर के निर्माण का वर्णन C # में करूंगा, OpenGL के लिए मैं OpenTK लाइब्रेरी का उपयोग करूंगा । आपको इसे डाउनलोड करने की आवश्यकता है, और विज़ुअल स्टूडियो में इस लाइब्रेरी के लिए एक लिंक बनाने की आवश्यकता है।

3 डी दौरा

अब 3 डी के बारे में थोड़ा विवरण। 3D में ऑब्जेक्ट्स में हमारे 3 निर्देशांक x, y, z और मॉनिटर स्क्रीन पर केवल दो निर्देशांक हैं। जाहिर है, प्रोजेक्शन को मॉनिटर स्क्रीन पर दिखाया जाना चाहिए।

लेकिन बैक ऑब्जेक्ट्स या जो बग़ल में खड़े हैं, हमें प्रोजेक्ट नहीं करना चाहिए। इसके अलावा, हमें ऐसी परियोजनाएँ नहीं करनी चाहिए जो बहुत दूर हैं। (रेसिंग में कैसे याद रखें, जब आप उनसे संपर्क करना शुरू करते हैं तो दूर की वस्तुएं दिखाई देती हैं)।

इसलिए, हमें सीमित होना चाहिए कि हम क्या देख सकते हैं:

इस तरह के एक काटे गए पिरामिड को फ्रस्ट्रम (FrustRum) कहा जाता है, स्क्रीन पर ऑब्जेक्ट को दिखाने के लिए, हम निर्धारित करते हैं कि क्या यह फ्रस्ट्रम (उन हिस्सों में फिट नहीं होता है जो हम कट नहीं करते हैं), फिर हम स्क्रीन पर प्रोजेक्ट करते हैं। यह सब हमारे लिए ओपनजीएल द्वारा किया जाता है।

पंख परीक्षण

OpenTK लाइब्रेरी डाउनलोड करें । फ़ाइल चलाएँ, लायब्रेरी को अनपैक करें।

एक प्रोजेक्ट बनाएं, OpenTK.dll फ़ाइल के लिए एक लिंक जोड़ें। और जब से हम GLControl नियंत्रण का उपयोग करेंगे, जिस पर Rubik's Cube प्रदर्शित किया जाएगा, हम OpenTK.GLControl.dll का लिंक भी जोड़ते हैं
OpenTK को भी System.Drawing.dll के लिए एक लिंक की आवश्यकता होती है, इसलिए एक बार फिर हम एक लिंक जोड़ने के लिए इंटरफ़ेस में जाते हैं, और .Net टैब का चयन करें और System.Drawing के लिए देखें, और जोड़ें।

OpenTK लाइब्रेरी को जोड़ना

मैं एक नियमित GUI प्रोग्राम के अंदर OpenGL का उपयोग करूंगा। इसलिए, डिज़ाइन मोड में, हम टूलबार पर राइट-क्लिक करते हैं और "सिलेक्ट एलीमेंट्स" का चयन करते हैं, ".NET फ्रेमवर्क के घटक" टैब पर जाएं और OpenTK.GLControl.dll फ़ाइल चुनें। सूची में एक नया GLControl तत्व दिखाई देगा, इसके सामने एक चेकमार्क रखें। ठीक है। टूलबार पर एक नया GLControl आइटम दिखाई देगा। हम इसे फ़ॉर्म में स्थानांतरित करते हैं और इसे इसके संपूर्ण रूप तक फैलाते हैं।

GLControl नियंत्रण जोड़ना (कैनवास, कैनवास)

GLControl तत्व में एक लोड ईवेंट है, जब यह तत्व लोड होता है तो यह आग लग जाती है।
(हैंडलर के शरीर को भरने के लिए उस पर क्लिक करें, glControl1_Load विधि दिखाई देगी)
OpenTK के निर्माता इसे बूट करने से पहले GLControl के साथ काम शुरू करने की सलाह नहीं देते हैं, इसलिए आपको एक चर शुरू करने की आवश्यकता है जो मान को संग्रहीत करेगा कि क्या GLControl ने बूट किया है:

कोड

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using OpenTK; using OpenTK.Graphics.OpenGL; namespace habr { public partial class Form1 : Form { bool loaded = false;//<-------------------------------------- public Form1() { InitializeComponent(); } private void glControl1_Load(object sender, EventArgs e) { loaded = true;//<-------------------------------------- } private void glControl1_Paint(object sender, PaintEventArgs e) { if (!loaded)//<-------------------------------------- return;//<-------------------------------------- } } }

glControl1_Load - एक विधि जो लोड घटना को संसाधित करती है
glControl1_Paint - एक विधि, जो पेंट ईवेंट को संसाधित करती है, उदाहरण के लिए, जब हम छिपाते हैं और तब विंडो को फिर से खोलते हैं या, उदाहरण के लिए, विंडो का आकार बदलें।

वास्तव में एक घन ड्रा।

एक छोटा सा घन आरेखण कोड

 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using OpenTK; using OpenTK.Graphics.OpenGL; namespace habr { public partial class Form1 : Form { bool loaded = false; public Form1() { InitializeComponent(); } private void glControl1_Load(object sender, EventArgs e) { loaded = true; GL.ClearColor(Color.SkyBlue); GL.Enable(EnableCap.DepthTest); Matrix4 p = Matrix4.CreatePerspectiveFieldOfView((float)(80 * Math.PI / 180), 1, 20, 500); GL.MatrixMode(MatrixMode.Projection); GL.LoadMatrix(ref p); Matrix4 modelview = Matrix4.LookAt(70, 70, 70, 0, 0, 0, 0, 1, 0); GL.MatrixMode(MatrixMode.Modelview); GL.LoadMatrix(ref modelview); } private void glControl1_Paint(object sender, PaintEventArgs e) { if (!loaded) return; GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); float width = 20; /**/ GL.Color3(Color.Red); GL.Begin(BeginMode.Polygon); GL.Vertex3(0, 0, 0); GL.Vertex3(width, 0, 0); GL.Vertex3(width, width, 0); GL.Vertex3(0, width, 0); GL.End(); /**/ GL.Begin(BeginMode.Polygon); GL.Vertex3(0, 0, 0); GL.Vertex3(0, 0, width); GL.Vertex3(0, width, width); GL.Vertex3(0, width, 0); GL.End(); /**/ GL.Begin(BeginMode.Polygon); GL.Vertex3(0, 0, 0); GL.Vertex3(0, 0, width); GL.Vertex3(width, 0, width); GL.Vertex3(width, 0, 0); GL.End(); /**/ GL.Begin(BeginMode.Polygon); GL.Vertex3(0, width, 0); GL.Vertex3(0, width, width); GL.Vertex3(width, width, width); GL.Vertex3(width, width, 0); GL.End(); /**/ GL.Begin(BeginMode.Polygon); GL.Vertex3(0, 0, width); GL.Vertex3(width, 0, width); GL.Vertex3(width, width, width); GL.Vertex3(0, width, width); GL.End(); /**/ GL.Begin(BeginMode.Polygon); GL.Vertex3(width, 0, 0); GL.Vertex3(width, 0, width); GL.Vertex3(width, width, width); GL.Vertex3(width, width, 0); GL.End(); /**/ GL.Color3(Color.Black); GL.Begin(BeginMode.LineLoop); GL.Vertex3(0, 0, 0); GL.Vertex3(0, width, 0); GL.Vertex3(width, width, 0); GL.Vertex3(width, 0, 0); GL.End(); GL.Begin(BeginMode.LineLoop); GL.Vertex3(width, 0, 0); GL.Vertex3(width, 0, width); GL.Vertex3(width, width, width); GL.Vertex3(width, width, 0); GL.End(); GL.Begin(BeginMode.LineLoop); GL.Vertex3(0, 0, width); GL.Vertex3(width, 0, width); GL.Vertex3(width, width, width); GL.Vertex3(0, width, width); GL.End(); GL.Begin(BeginMode.LineLoop); GL.Vertex3(0, 0, 0); GL.Vertex3(0, 0, width); GL.Vertex3(0, width, width); GL.Vertex3(0, width, 0); GL.End(); glControl1.SwapBuffers(); } } }

OpenTK का उपयोग करना; - मैट्रिक्स 4 वर्ग (4x4 मैट्रिक्स) के लिए आवश्यक
OpenTK.Graphics.OpenGL का उपयोग करना; - जीएल ऑब्जेक्ट तक पहुंचने के लिए आवश्यक।

GL एक ऐसी वस्तु है जिसके माध्यम से वास्तव में OpenGL कमांड को कॉल किया जाता है।
GL.ClearColor (Color.SkyBlue); - नीले रंग से भरता है
GL.Enable (EnableCap.DepthTest); - इस लाइन की आवश्यकता है ताकि दूर के तत्व निकटतम को ओवरलैप करें।

 Matrix4 p = Matrix4.CreatePerspectiveFieldOfView((float)(80 * Math.PI / 180), 1, 20, 500); GL.MatrixMode(MatrixMode.Projection); GL.LoadMatrix(ref p);

यहां हम उस मैट्रिक्स को सेट करते हैं जो फ्रस्ट्रम के लिए जिम्मेदार है:
1) 80 डिग्री का कोण देखना
2) लंबाई का अनुपात - 1
3) पहले चेहरे की दूरी - 20
4) दूर की तरफ दूरी - 500

प्रोजेक्शन मोड पर जाएं, और इस मैट्रिक्स को सेट करें। मोड के बारे में बाद में चर्चा की जाएगी।

 GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

प्रारंभ ColorBufferBit और DepthBuffer

ColorBuffer। रंग बफ़र। स्क्रीन पर प्रत्येक पिक्सेल का रंग मान होता है जो रंग बफर में दर्ज होता है। हमारे मामले में GL.Clear (ClearBufferMask.ColorBufferBit) को कॉल करने पर विंडो स्काईब्लू (ऊपर देखें) रंग से भर जाएगी।

DepthBuffer। वह जेड-बफर है। गहराई बफर। तथ्य यह है कि 3 डी अंतरिक्ष में दो बिंदुओं को स्क्रीन पर एक बिंदु पर पेश किया जा सकता है। यह आवश्यक है कि निकट बिंदु बहुत दूर तक ओवरलैप हो। ऐसा करने के लिए, आपको बिंदु की "गहराई" की गणना करने की आवश्यकता है (मूल्य कैमरे से बिंदु तक की दूरी के आनुपातिक रूप से आनुपातिक है) और बफर में इसके मूल्य को रिकॉर्ड करें (जैसे पिक्सेल, ऐसी गहराई), आदि
यदि अगले बिंदु को एक ही पिक्सेल पर प्रक्षेपित किया जाता है, तो आपको नए बिंदु की "गहराई" की तुलना रिकॉर्ड किए गए गहराई बफर से करने की आवश्यकता है। यदि नया बिंदु "कम गहरा" (कैमरे के करीब) है, तो इसके प्रक्षेपण को मौजूदा एक को ओवरलैप करना चाहिए, अन्यथा हम सब कुछ उसी तरह छोड़ देते हैं।
घन प्रदान करने की शुरुआत में, हमें गहराई-बफर को साफ करना चाहिए।

 Matrix4 modelview = Matrix4.LookAt(70, 70, 70, 0, 0, 0, 0, 1, 0); GL.MatrixMode(MatrixMode.Modelview); GL.LoadMatrix(ref modelview);

यहां हमने अपना कैमरा बिंदु (30, 70, 80) पर सेट किया, समन्वय प्रणाली के केंद्र में दृष्टि की दिशा (0, 0, 0)। अभिविन्यास ऐसा है कि ओए अक्ष को निर्देशित किया जाता है।

अगर हम करते हैं

 Matrix4 modelview = Matrix4.LookAt(30, 70, 80, 0, 0, 0, 1, 1, 0);

फिर हम एक कोण पर क्यूब को देखेंगे, जैसे कि हमने अपना सिर 45 डिग्री बाईं ओर झुका दिया था।

इसके बाद, घन वास्तव में खींचा जाता है: पहले चेहरे लाल होते हैं, फिर किनारे काले होते हैं

फिर कमांड कहा जाता है

 glControl1.SwapBuffers();

तथ्य यह है कि, डिफ़ॉल्ट रूप से, OpenTK में OpenGL डबल-बफर है: प्रत्येक बफर (ColorBuffer, DepthBuffer और अन्य जिनका मैंने उल्लेख नहीं किया था) की नकल की गई है। जब हम कोई चित्र बनाते हैं, तो हम केवल बफ़र्स का उपयोग करते हैं। इस समय, स्क्रीन एक छवि प्रदर्शित करती है जो अन्य बफ़र्स से प्राप्त की जाती है।
GlControl1.SwapBuffers (); हम बफ़र्स का उपयोग करके छवि प्रदर्शित करते हैं जिसमें हमने इसे चित्रित किया है।
वैसे, यदि आप पहली बार केवल रंगीन बफर को साफ करते हैं

 bool b = true; private void glControl1_Paint(object sender, PaintEventArgs e) { if (!loaded) return; GL.Clear(ClearBufferMask.DepthBufferBit); if (b) { GL.Clear(ClearBufferMask.ColorBufferBit); } b = false; …

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

अब मोड्स के बारे में

ऑब्जेक्ट्स को 3-आयामी निर्देशांक में निर्दिष्ट किया गया है। इन निर्देशांक को ऑब्जेक्ट निर्देशांक कहा जाता है। प्रत्येक वस्तु को उसके निर्देशांक में परिभाषित किया जा सकता है। अलग-अलग थ्री डी ऑब्जेक्ट्स की दुनिया बनाने के लिए जो अलग-अलग स्थिति में एक-दूसरे के सापेक्ष खड़े होते हैं,
आपको संबंधित मॉडल मैट्रिक्स (मॉडल मैट्रिक्स) द्वारा प्रत्येक ऑब्जेक्ट के ऑब्जेक्ट निर्देशांक को गुणा करना होगा। तब हमें प्रत्येक वस्तु के नए निर्देशांक एक नए सामान्य विश्व स्थान में मिलते हैं।

उसी समय, हम विभिन्न पक्षों से वस्तुओं की दुनिया को देख सकते हैं, हम कैमरे को पलट सकते हैं, हम ऑब्जेक्ट को पास कर सकते हैं और उससे दूर जा सकते हैं। दृश्य परिवर्तन (दृश्य मैट्रिक्स) के संगत मैट्रिक्स द्वारा वस्तुओं के निर्देशांक (विश्व अंतरिक्ष में निर्देशांक) को गुणा करते हुए, हम प्रत्येक ऑब्जेक्ट के दृश्य निर्देशांक प्राप्त करते हैं।

ओपनजीएल में, मॉडल ट्रांसफ़ॉर्मेशन मैट्रिक्स को व्यू ट्रांसफ़ॉर्मेशन मैट्रिक्स के साथ एक (मॉडल व्यू मैट्रिक्स) में जोड़ा जाता है। (आखिरकार, हम किसी वस्तु को दो तरीकों से हटा सकते हैं: इसके विश्व निर्देशांक (वस्तु को दूर ले जाएं) को बदलें, या कैमरे को इससे दूर ले जाएं (नया दृश्य निर्देशांक प्राप्त करें)।

फिर समन्वय मैट्रिक्स (प्रक्षेपण मैट्रिक्स) द्वारा गुणा किया जाता है, जो या तो हताशा (परिप्रेक्ष्य प्रक्षेपण) को सेट करता है:

या ऑर्थोगोनल प्रक्षेपण सेट करता है:

प्रक्षेपण मैट्रिक्स द्वारा दृश्य निर्देशांक को गुणा करते हुए, हम काटे गए निर्देशांक (क्लिप निर्देशांक) प्राप्त करते हैं। प्रत्येक निर्देशांक (x, y, z) को inate के मान से विभाजित करते हुए, हम डिवाइस के सामान्यीकृत निर्देशांक (Normalize Device Coordinates, NDC) प्राप्त करते हैं, जिनमें से प्रत्येक -1 से 1 तक है, जबकि Z अक्ष पहले से ही हमारे द्वारा तैनात किया गया है (अर्थात, Frustrum अनिवार्य रूप से है) एक घन में बदल जाता है और हमसे 180 डिग्री घूमता है)
इसके अलावा, निर्देशांक को खिड़की के निर्देशांक में स्थानांतरित और स्केल किया जाता है, जो अंततः स्क्रीन पर 2 डी छवि के निर्माण में शामिल होते हैं।

प्रोजेक्शन मैट्रिक्स कंट्रोल मोड पर जाने के लिए, हमें मैट्रिक्स मैट्रिक्स के साथ GL.MatrixMode फ़ंक्शन को कॉल करना होगा। पैरामीटर:
GL.MatrixMode (MatrixMode.Projection);

और मॉडल-व्यू ट्रांसफ़ॉर्मेशन मैट्रिक्स कंट्रोल मोड पर स्विच करने के लिए, हमें मैट्रिक्स मैट्रिक्स के साथ GL.MatrixMode फ़ंक्शन को कॉल करना होगा। पैरामीटर पैरामीटर:
GL.MatrixMode (MatrixMode.ModelView);

GlControl1_Paint में कोड जोड़ें जो कुल्हाड़ियों को खींचता है OX, OY, OZ:

 GL.Color3(Color.Black); GL.Begin(BeginMode.Lines); GL.Vertex3(0, 0, 0); GL.Vertex3(50, 0, 0); GL.Vertex3(0, 0, 0); GL.Vertex3(0, 50, 0); GL.Vertex3(0, 0, 0); GL.Vertex3(0, 0, 50); GL.End();

फॉर्म डिज़ाइनर में भी, आपको कीडाउन इवेंट के लिए हैंडलर जोड़ने की जरूरत है, glControl1_KeyDown फ़ंक्शन दिखाई देगा। इसे निम्नलिखित कोड से भरें:

 private void glControl1_KeyDown(object sender, KeyEventArgs e) { if (!loaded) return; if (e.KeyCode == Keys.A) { GL.MatrixMode(MatrixMode.Projection); GL.Rotate(30, 0, 0, 1); } if (e.KeyCode == Keys.B) { GL.MatrixMode(MatrixMode.Modelview); GL.Rotate(30, 0, 0, 1); } glControl1.Invalidate(); }

यही है, जब आप कीबोर्ड पर A कुंजी दबाते हैं, तो हम प्रक्षेपण मोड में जाते हैं और OZ अक्ष 30 डिग्री वामावर्त के चारों ओर घूमते हैं,
और जब आप B कुंजी दबाते हैं, तो OZ अक्ष के चारों ओर रोटेशन भी किया जाता है, लेकिन पहले से ही मॉडल-विशिष्ट रूपांतरण मोड में।

मैं यहां पूरा कोड देता हूं:

एक छोटा घन जो A और B दबाकर घूमता है

 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using OpenTK; using OpenTK.Graphics.OpenGL; namespace habr { public partial class Form1 : Form { float width = 20; bool loaded = false; public Form1() { InitializeComponent(); } private void Form1_Load(object sender, EventArgs e) { } private void glControl1_Load(object sender, EventArgs e) { loaded = true; GL.ClearColor(Color.SkyBlue); GL.Enable(EnableCap.DepthTest); Matrix4 p = Matrix4.CreatePerspectiveFieldOfView((float)(80 * Math.PI / 180), 1, 20, 500); GL.MatrixMode(MatrixMode.Projection); GL.LoadMatrix(ref p); Matrix4 modelview = Matrix4.LookAt(70, 70, 70, 0, 0, 0, 0, 1, 0); GL.MatrixMode(MatrixMode.Modelview); GL.LoadMatrix(ref modelview); } private void glControl1_KeyDown(object sender, KeyEventArgs e) { if (!loaded) return; if (e.KeyCode == Keys.A) { GL.MatrixMode(MatrixMode.Projection); GL.Rotate(30, 0, 0, 1); } if (e.KeyCode == Keys.B) { GL.MatrixMode(MatrixMode.Modelview); GL.Rotate(30, 0, 0, 1); } glControl1.Invalidate(); } private void glControl1_Paint(object sender, PaintEventArgs e) { if (!loaded) return; GL.Clear(ClearBufferMask.DepthBufferBit | ClearBufferMask.ColorBufferBit); /**/ GL.Color3(Color.Red); GL.Begin(BeginMode.Polygon); GL.Vertex3(0, 0, 0); GL.Vertex3(width, 0, 0); GL.Vertex3(width, width, 0); GL.Vertex3(0, width, 0); GL.End(); /**/ GL.Begin(BeginMode.Polygon); GL.Vertex3(0, 0, 0); GL.Vertex3(0, 0, width); GL.Vertex3(0, width, width); GL.Vertex3(0, width, 0); GL.End(); /**/ GL.Begin(BeginMode.Polygon); GL.Vertex3(0, 0, 0); GL.Vertex3(0, 0, width); GL.Vertex3(width, 0, width); GL.Vertex3(width, 0, 0); GL.End(); /**/ GL.Begin(BeginMode.Polygon); GL.Vertex3(0, width, 0); GL.Vertex3(0, width, width); GL.Vertex3(width, width, width); GL.Vertex3(width, width, 0); GL.End(); /**/ GL.Begin(BeginMode.Polygon); GL.Vertex3(0, 0, width); GL.Vertex3(width, 0, width); GL.Vertex3(width, width, width); GL.Vertex3(0, width, width); GL.End(); /**/ GL.Begin(BeginMode.Polygon); GL.Vertex3(width, 0, 0); GL.Vertex3(width, 0, width); GL.Vertex3(width, width, width); GL.Vertex3(width, width, 0); GL.End(); GL.Color3(Color.Black); GL.Begin(BeginMode.LineLoop); GL.Vertex3(0, 0, 0); GL.Vertex3(0, width, 0); GL.Vertex3(width, width, 0); GL.Vertex3(width, 0, 0); GL.End(); GL.Begin(BeginMode.LineLoop); GL.Vertex3(width, 0, 0); GL.Vertex3(width, 0, width); GL.Vertex3(width, width, width); GL.Vertex3(width, width, 0); GL.End(); GL.Begin(BeginMode.LineLoop); GL.Vertex3(0, 0, width); GL.Vertex3(width, 0, width); GL.Vertex3(width, width, width); GL.Vertex3(0, width, width); GL.End(); GL.Begin(BeginMode.LineLoop); GL.Vertex3(0, 0, 0); GL.Vertex3(0, 0, width); GL.Vertex3(0, width, width); GL.Vertex3(0, width, 0); GL.End(); GL.Color3(Color.Black); GL.Begin(BeginMode.Lines); GL.Vertex3(0, 0, 0); GL.Vertex3(50, 0, 0); GL.Vertex3(0, 0, 0); GL.Vertex3(0, 50, 0); GL.Vertex3(0, 0, 0); GL.Vertex3(0, 0, 50); GL.End(); glControl1.SwapBuffers(); } } }

यदि हम कीबोर्ड पर अक्षर A दबाते हैं, तो हम स्क्रीन पर 2D छवि को घुमाएंगे:

इस प्रकार, परिप्रेक्ष्य निर्देशांक में, OZ अक्ष भी Froustrum अक्ष है।

यदि B को कीबोर्ड पर दबाया जाता है, तो निर्देशांक प्रणाली OZ अक्ष के चारों ओर घूमेगी:

कोड

 GL.MatrixMode(MatrixMode.Projection); GL.Rotate(30, 0, 0, 1);

उसी सफलता के साथ इसे प्रतिस्थापित किया जा सकता है:

 Matrix4d projection_matrix;// 4x4,   double GL.GetDouble(GetPName.ProjectionMatrix, out projection_matrix);//    projection_matrix //     OZ double cos = Math.Cos(-30 * Math.PI / 180); double sin = Math.Sin(-30 * Math.PI / 180); Matrix4d rotating_matrix = new Matrix4d( cos, -sin, 0, 0, sin, cos, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ); projection_matrix *= rotating_matrix;//      GL.MatrixMode(MatrixMode.Projection);//    GL.LoadMatrix(ref projection_matrix);//

मॉडलव्यू मैट्रिक्स के ऊपर समान कोड समान परिणाम देगा।

दरअसल, चलो रूबिक क्यूब एमुलेटर प्रोग्राम के विवरण पर चलते हैं, जिसे आप यहां डाउनलोड कर सकते हैं: http: //trukoding.rf/files/opengl.zip

अंत में,

मैं सब कुछ का वर्णन नहीं करूंगा, क्योंकि बहुत अधिक पाठ होगा। मैं मुख्य बिंदुओं का वर्णन करूंगा।

मुख्य डेटा संरचनाएँ

1) रूबिक का घन, जिसके किनारे में 3 घन होते हैं, जिसमें 27 छोटे घन होते हैं।
रूबिक के क्यूब (केआर) के चेहरे के रोटेशन के दौरान, छोटे क्यूब्स उनके स्थान को बदल देंगे। सीआर के चेहरे को घुमाने की प्रक्रिया में, आपको यह जानने की जरूरत है कि कौन से छोटे क्यूब्स को घुमाने के लिए (आखिरकार, विभिन्न क्यूब्स चेहरे में दिखाई दे सकते हैं), सीआर के चेहरे के अगले रोटेशन के बाद, आपको यह जांचने की आवश्यकता है कि क्यूब को इकट्ठा किया गया है या नहीं।

ब्लॉकों की स्थितियों को ट्रैक करने के लिए, मैंने पदों की एक सरणी लागू की:
int [] पदों;

उनकी चाबियाँ क्यूब्स की संख्या, और पदों की संख्या के मान हैं।

वैसे, मैंने पदों को निम्नानुसार निर्दिष्ट किया है:

2) जब आप सीडी चेहरे को घुमाते हैं, तो संबंधित छोटे क्यूब्स न केवल स्थान बदलते हैं, बल्कि अन्य पक्षों द्वारा घुमाते हैं। जब हमने किनारे को एक मोड़ दिया (90 डिग्री),
तब घन की नई अवस्था दो तरह से प्राप्त की जा सकती है:
1) एक निश्चित अक्ष 90 डिग्री के आसपास इसी क्यूब्स को घुमाएं (जो मोड़ते समय किया गया था)
2) या तो क्यूब्स को नए स्थानों पर पुनर्व्यवस्थित करें, और प्रत्येक क्यूब को अपनी धुरी पर 90 डिग्री से घुमाएं।

अगली कक्षा का उपयोग अंतरिक्ष में घन का वर्णन करने के लिए किया जाता है।

 public class angleXYZ { public angleXYZ() { this.X = 0; this.Y = 0; this.Z = 0; } public int X { get; set; } public int Y { get; set; } public int Z { get; set; } }

फ़ील्ड X, Y, Z, कुल्हाड़ियों OX, ओए, OZ के सापेक्ष कोण हैं
जब हम एक चेहरे को घुमाते हैं, तो संबंधित क्यूब संबंधित क्यूब्स में बदल जाता है।
रोटेशन पूरा होने के बाद, मैं इन कोणों को रीसेट करता हूं, क्यूब्स को नए पदों पर ले जाता हूं (अर्थात, स्थिति सरणी को तदनुसार बदल दें), और क्यूब्स को अपनी धुरी के चारों ओर घुमाएं (मैं दिखाऊंगा कि मेरा क्या मतलब है)। उपयोगकर्ता केवल रोटेशन को ही देखता है।

प्रत्येक क्यूब में क्लास एंगलएक्सवाईजेड की एक वस्तु होती है और इसे कोणों के संग्रह में संग्रहीत किया जाता है:

 List<angleXYZ> angles = new List<angleXYZ>();

3) प्रत्येक घन में 8 कोने बिंदु होते हैं। इन बिंदुओं को जानना, क्यूब खींचना कोई समस्या नहीं है।
अंक के निर्देशांक किनारों के 3-आयामी सरणी में संग्रहीत किए जाते हैं। केवल गुणन कार्यों (जोड़ और गुणा के बजाय) का उपयोग करके निर्देशांक को स्थानांतरित करने और घुमाने के लिए, मैं निर्देशांक के लिए 1x4 मैट्रिसेस का उपयोग करता हूं और स्थानांतरण और गुणा मैट्रिस के लिए 4x4 मैट्रिस का उपयोग करता हूं।
4x4 मैट्रिसेस का उपयोग करने से आप गुणा के संचालन को एक साथ जोड़ सकते हैं और ट्रांसफर मैट्रिक्स, और रोटेशन कर सकते हैं। इस प्रकार, दो चीजें एक गुणन ऑपरेशन में की जा सकती हैं: संक्रमण और गुणा दोनों।

 float[][][] edges; … // edges = new float[n][][];//n -   (27,  3x3x3) … for (int i = 0; i < n; i++) { float[][] vectors = new float[8][] { //w-   new float[4] { 0, 0, 0, 1 }, new float[4] { 0, 0, w, 1 }, new float[4] { 0, w, 0, 1 }, new float[4] { 0, w, w, 1 }, new float[4] { w, 0, 0, 1 }, new float[4] { w, 0, w, 1 }, new float[4] { w, w, 0, 1 }, new float[4] { w, w, w, 1 }, }; edges[i] = vectors; … //  List<int> data = getOffsets(i); int offset_x = data[0]; int offset_z = data[1]; int offset_y = data[2]; for (int j = 0; j < edges[i].Length; j++) { //w -  , spacing -    //(    ) edges[i][j][0] += offset_x * (w + spacing); edges[i][j][1] += offset_y * (w + spacing); edges[i][j][2] += offset_z * (w + spacing); } }

इकट्ठे सीआर में शून्य स्थिति के सापेक्ष अगले छोटे क्यूब (जिसमें से रूबिक के क्यूब होते हैं) का पता लगाने के लिए, मैंने एक विशेष फ़ंक्शन गेटऑफ़सेट लिखा, जो क्यूब की संख्या लेता है और रिटर्न करता है कि आपको प्रत्येक अक्ष के साथ कितने क्यूब्स को पीछे हटने की आवश्यकता है।

4) एक शब्दकोश भी है intersect_planes।
शब्दकोश कुंजी कुल्हाड़ियों हैं (एक्सिस एन्यूमरेशन ऑब्जेक्ट (सार्वजनिक एनम एक्सिस {एक्स, वाई, जेड};));
और मूल्य इसी धुरी पर अंकित होते हैं, मेरी कक्षा की विमान (विमान) की वस्तुएं।

 public enum Axis { X, Y, Z }; Dictionary<Axis, Plane[]> intersect_planes = new Dictionary<Axis,Plane[]>();

प्रत्येक चेहरे के कोने के बिंदुओं के निर्देशांक को संग्रहीत करने के लिए प्लेन क्लास की आवश्यकता होती है।

 side = N * w + (N - 1) * spacing;// -   //   Vector3 p1 = new Vector3(0, side, side);//<---- Vector3 p2 = new Vector3(side, 0, side); Vector3 p3 = new Vector3(side, side, side);//<---- Vector3 p4 = new Vector3(side, 0, 0); Vector3 p5 = new Vector3(0, 0, 0); Vector3 p6 = new Vector3(0, side, 0);//<---- Vector3 p7 = new Vector3(0, 0, side); Vector3 p8 = new Vector3(side, side, 0); intersect_planes[Axis.X] = new Plane[2] { new Plane(p2, p3, p8),// 2, 5, 8, 11, 14, 17, 23, 20, 26  X new Plane(p1, p7, p5)// 0, 3, 6, 9, 12, 15, 18, 21, 24  X }; intersect_planes[Axis.Y] = ... ….

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

 intersect_planes[Axis.X] = new Vector3[2][] { new Vector3[]{p2, p3, p8},// 2, 5, 8, 11, 14, 17, 23, 20, 26  X new Vector3[]{p1, p7, p5},// 0, 3, 6, 9, 12, 15, 18, 21, 24  X };

लेकिन वर्ग कोष्ठक की एक श्रृंखला के माध्यम से सरणी के तत्वों का उपयोग करने के लिए कष्टप्रद।

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

5) मेरी वीपी क्लास व्यूपॉइंट की एक महत्वपूर्ण वस्तु।

 ViewPoint vp = new ViewPoint();

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

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

दृष्टिकोण एक क्षेत्र में रूबिक के घन के चारों ओर घूमता है, इसलिए अक्ष OX (कोण α) के सापेक्ष कोण और महासागर और ओए (कोण β) के सापेक्ष कोण के साथ संचालित करना सुविधाजनक है:

वीपी ऑब्जेक्ट पर, सेटर गुण angle_view_alpha और angle_view_beta खुले हैं, उनके माध्यम से कोण α और कोण, बदल दिए जाते हैं, और सेटर्स के शरीर में कैमरे के निर्देशांक (व्यूप्वाइंट) इन कोणों से गणना की जाती है।
इस वर्ग में गटर गुण भी होते हैं जिनका उपयोग यह निर्धारित करने के लिए किया जा सकता है कि कैमरा उल्टा है, किसी निश्चित अक्ष के किस तरफ हम क्यूब को देख रहे हैं (उदाहरण के लिए, सकारात्मक X मानों की तरफ से, या नकारात्मक Z मानों की तरफ से)।
रुबिक के क्यूब के किनारों को मोड़ने के लिए किन दिशाओं को सही ढंग से निर्धारित किया जाए, इसके लिए यह आवश्यक है। रूबिक का क्यूब स्वयं स्थित है ताकि इसका केंद्र मूल के केंद्र में हो।

कोड पर चलते हैं

मैं केवल मुख्य बिंदुओं का वर्णन करूंगा, अन्यथा यह बहुत लंबा होगा। मैं पहले से ही खुद को लियो निकोलाइविच महसूस करता हूं।

रेंडर विधि

मैं रूबिक क्यूब को खुद खींचना चाहता हूं ताकि इसका केंद्र मूल के केंद्र के साथ मेल खाता हो, इसलिए जब मैं मॉडलव्यू मैट्रिक्स मोड पर स्विच करता हूं, तो मैं सभी अक्षों के साथ रूबिक क्यूब की लंबाई के लिए समन्वय प्रणाली को स्थानांतरित करता हूं:

 double offset0 = this.w * N + (N - 1) * spacing;//   w -   , N -   (3), spacing -    . double offset = offset0 / 2; GL.Translate( -offset, -offset, -offset );

फिर, क्यूब्स की संख्या (27 गुना) से, क्यूब फ़ंक्शन को कहा जाता है, जो छोटे क्यूब्स को खींचता है, सिवाय इसके कि यह सीडी के केंद्र में है, क्योंकि यह कभी नहीं देखा जाएगा।

घन समारोह

मैं सबसे पहले OpenGL द्वारा प्रदान किए गए स्टैक में वर्तमान ModelView मैट्रिक्स को बचाता हूँ:

 GL.PushMatrix();

और अंत में मैं इस मैट्रिक्स को स्टैक से पुनर्स्थापित करता हूं:

 GL.PopMatrix();

यह आवश्यक है ताकि एक क्यूब के मॉडलव्यू मैट्रिक्स (घुमाव, स्थानान्तरण) को बदलना अन्य क्यूब्स के मेट्रिसेस को प्रभावित न करे। दूसरे शब्दों में, यदि हम एक छोटे क्यूब को मोड़ना चाहते हैं, तो दूसरों को स्पिन नहीं करना चाहिए।

एक चेहरे की स्क्रॉल को चेतन करने के लिए, मैं एक कुल्हाड़ी के चारों ओर घूमता हूं।

 float offset = (w * N + (N - 1) * spacing) / 2;//    GL.Translate( offset, offset, offset ); GL.Rotate(angle.X, Vector3.UnitX); GL.Rotate(angle.Y, Vector3.UnitY); GL.Rotate(angle.Z, Vector3.UnitZ); GL.Translate( -offset, -offset, -offset );

कोड इस तरह से लिखा गया है कि केवल कोणों में से एक कोण। X, angle.Y, angle.Z एक क्षण में नॉनजरो हो सकता है, इसलिए यहां यह केवल एक अक्ष के चारों ओर घूमता है, या बिल्कुल भी निष्पादित नहीं करता है।

लेकिन, इस बात को ध्यान में रखते हुए कि समन्वय प्रणाली को स्थानांतरित कर दिया गया है, आपको पहले इसे अपनी जगह पर वापस करना होगा, एक मोड़ बनाना होगा, और फिर से रिवर्स ट्रांसफर करना होगा, जो मैंने किया था:

अगला, किनारों के सरणी का उपयोग क्यूब खींचने के लिए किया जाता है, क्यूब के चेहरों के रंग घन की संख्या से निर्धारित होते हैं, जो क्यूब फ़ंक्शन को पास किया जाता है।

तीर

केंद्र अपने मूल स्थान पर GL.Translate रिटर्न का उपयोग कर प्रणाली का समन्वय करता है।
फिर, व्यूप्वाइंट क्लास के वीपी का उपयोग करते हुए, कैमरे के निकटतम समन्वय प्रणाली की धुरी निर्धारित की जाती है और किस तरफ से है।संबंधित रोटेशन GL.Rotate का उपयोग करके बनाया गया है और GL.Translate विधि ऐसा स्थानांतरण बनाती है ताकि तीर निकटतम चेहरे पर आरेखित हो।

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

ऐसी सीधी रेखा के 2 बिंदुओं को निर्धारित करने के लिए, डिवाइस के सामान्यीकृत निर्देशांक (एनडीसी, ऊपर चर्चा की गई) पाए जाते हैं, जिसे मॉडलव्यू मैट्रिस और प्रोजेक्शन को गुणा करके प्राप्त उल्टे मैट्रिक्स द्वारा गुणा किया जाना चाहिए।
नतीजतन, हम फ्रोस्ट्रम के निकटतम और दूर के विमानों पर पड़े दो बिंदुओं के निर्देशांक प्राप्त करते हैं।

 System.Windows.Forms.MouseEventArgs me = (e as System.Windows.Forms.MouseEventArgs); double y = me.Y; double x = me.X; int w = glControl1.Width; int h = glControl1.Height; float xpos = (float)(2 * (x / w) - 1); float ypos = (float)(2 * (1 - y / h) - 1); Vector4 startRay = new Vector4(xpos, ypos, 1, 1); Vector4 endRay = new Vector4(xpos, ypos, -1, 1); // Reverse Project Matrix4 modelview = new Matrix4(); Matrix4 projection = new Matrix4(); GL.GetFloat(GetPName.ModelviewMatrix, out modelview); GL.GetFloat(GetPName.ProjectionMatrix, out projection); Matrix4 trans = modelview * projection; trans.Invert(); startRay = Vector4.Transform(startRay, trans); endRay = Vector4.Transform(endRay, trans); sr = startRay.Xyz / startRay.W; er = endRay.Xyz / endRay.W;

फिर से रेंडर विधि पर जाएं

अप्रोचिंग फेस और लाइन के दो बिंदुओं को जानने के बाद, हम लाइन और चौराहे के चौराहे के बिंदु को खोजते हैं, जहां रूबिक क्यूब का चेहरा हमारे सबसे करीब है (यानी, प्रतिच्छेदन_प्लेन शब्दकोश जिसमें प्लेन के पॉइंट प्ले होते हैं)।

चौराहे बिंदु की परिभाषा निर्धारित करने का कार्य मैंने गुगुल किया। आगे, कोड में, यह उस चेहरे के लिए निर्धारित किया जाता है जिसे हमने या तो इसके किनारे पर (तीर की दिशा में), और चेहरे की तरफ से या ऊपर से नीचे तक क्लिक किया है। यह सब आसान है क्योंकि क्यूब स्वयं नहीं चलता है, और इसके किनारे XOY, XOZ, YOZ विमानों के समानांतर हैं (अर्थात, चौराहे के बिंदु के कम / अधिक निर्देशांक और 4 कोने बिंदुओं के निर्देशांक की तुलना करके सब कुछ निर्धारित किया जाता है)।
खैर, फिर हम चेहरे को घुमाने की प्रक्रिया शुरू करते हैं।

चेहरा घुमाना

चेहरे के रोटेशन को चेतन करने के लिए, मैंने ईजीइंगटाइमर क्लास बनाई, जो कि विरासत में मिली। सिस्टमटाइमर। चिमर, सिंगलटन डिजाइन पैटर्न का उपयोग करके, आप इस वर्ग का केवल एक तत्व बना सकते हैं। मैंने ऐसा इसलिए किया ताकि संयोग से एक ही समय में दो चेहरे न घूमें। एक रन वैरिएबल भी है जो यह निर्धारित करता है कि रोटेशन प्रक्रिया चल रही है या नहीं और नई रोटेशन प्रक्रिया तब तक शुरू नहीं होती है जब तक कि पिछले एक समाप्त न हो जाए।

ईजिंगटाइमर वर्ग की एक वस्तु की अवधि संपत्ति मिलीसेकंड में रोटेशन की अवधि निर्धारित करती है।
रोटेशन ही ऐसा होता है:

प्रारंभिक समय बच जाता है
टाइमर प्रति 100 मिलीसेकंड में एक बार शुरू होता है।

, rotatePart , angles . , .

 public class angleXYZ { public angleXYZ() { this.X = 0; this.Y = 0; this.Z = 0; } public int X { get; set; } public int Y { get; set; } public int Z { get; set; } }

, X, Y, Z,
100 , , , .
, glControl1.Invalidate();, Render , cube , angles , . , .

rotatePart , duration .
, ( Render , , ).
positions ( , , ), . — , , .
, :

इसलिए, तत्व किनारों के एक सरणी होते हैं, जिसमें छोटे क्यूब्स के 8 बिंदुओं के निर्देशांक होते हैं जो घूर्णन को संबंधित रोटेशन मैट्रिक्स द्वारा गुणा किया जाता है।
फिर glControl1.Invalidate () पर कॉल के माध्यम से; रेंडर विधि कहा जाता है, जो क्यूब विधि को बुलाएगा, जो नए स्थानों में क्यूब्स को दिखाएगा और तदनुसार घुमाया जाएगा।

अब मैं समझाता हूं कि पदों के सरणी का आविष्कार क्यों किया गया था, यह दर्शाता है कि क्यूब किस स्थिति में है (27 क्यूब्स, 27 स्थिति)। तथ्य यह है कि रूबिक के क्यूब के चेहरे को घुमाने की प्रक्रिया में, छोटे क्यूब्स लगातार अपना स्थान बदल देंगे, और आपको एक्स अक्ष के चारों ओर "घुमाने वाले क्यूब नंबर 3 90 डिग्री" जैसी आज्ञाओं के साथ काम करने की आवश्यकता नहीं है, लेकिन इस तरह के कमांड जैसे कि यह क्यूब खड़े हैं। स्थिति 3 पर, एक्स अक्ष के आसपास 90 डिग्री। ”

अब मैं समझाता हूँ कि क्यों मैं अंतरिक्ष में घन को घुमाने के लिए जिम्मेदार कोण कोणों के तत्वों को शून्य करने के लिए रीसेट करता हूँ। तथ्य यह है कि मुड़ने का क्रम मायने रखता है। एक्स अक्ष के चारों ओर एक रोटेशन, फिर वाई अक्ष के चारों ओर एक रोटेशन वाई अक्ष के चारों ओर एक रोटेशन के रूप में ही नहीं है, और फिर एक्स अक्ष के चारों ओर एक रोटेशन।

यदि आप क्यूब्स के रोटेशन के कोण को कभी भी रीसेट नहीं करते हैं, तो क्यूब से निम्नलिखित कोड है कि रोटेशन एनीमेशन लागू

करता है सिर्फ पहले काम करेगा। तीन घुमाव, और फिर भी, यदि वे इस क्रम में हैं: एक्स के आसपास, वाई के आसपास, जेड के आसपास।

 GL.Rotate(angle.X, Vector3.UnitX); GL.Rotate(angle.Y, Vector3.UnitY); GL.Rotate(angle.Z, Vector3.UnitZ);

प्रत्येक क्यूब के रोटेशन के अनुक्रम को याद रखना आवश्यक है, आपके पास होने वाले घुमावों का एक निश्चित ट्रेस। किनारों के सरणी में छोटे क्यूब्स के कोने बिंदुओं के निर्देशांक होते हैं, जो प्रत्येक बार क्यूब के निर्देशांक को संबंधित रोटेशन मैट्रिक्स द्वारा गुणा करते हैं, हम इस क्यूब के सभी घुमावों के इतिहास को सहेजते हैं। हमें केवल किनारों के एरे के तत्व को पढ़ने और संबंधित क्यूब को प्रदर्शित करने की आवश्यकता है।

पूरे रुबिक के क्यूब का रोटेशन

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

ViewPoint वर्ग के vp ऑब्जेक्ट के संबंधित गुण, जो X- अक्ष और Y- अक्ष से कोणों के लिए ज़िम्मेदार होते हैं, उन्हें परिवर्तित किया जाता है (ऊपर चित्र देखें), और ViewPoint वर्ग के तरीकों के अंदर, कैमरे के नए निर्देशांक निर्धारित किए जाते हैं और उल्टा हो जाते हैं, फिर एक नया मॉडल व्यू मैट्रिक्स बनाया जाता है:

 G_modelview = Matrix4.LookAt(vp.viewX, vp.viewY, vp.viewZ, 0, 0, 0, 0, vp.orintation_y, 0);

पहले 3 तत्व कैमरे के निर्देशांक निर्दिष्ट करते हैं,
दूसरे 3 तत्व निर्दिष्ट करते हैं कि कैमरे को निर्देशांक प्रणाली के केंद्र में निर्देशित किया जाएगा।
अंतिम 3 तत्व निर्दिष्ट करते हैं कि कैमरा कैसे घुमाया जाता
है यह निर्दिष्ट किया जाता है कि वाई अक्ष या तो ऊपर होगा यदि vp.orintation_y == 1, या नीचे अगर vp.orintation_y == -1 इसके

लिए है।
बाकी सब कुछ, मैं इसका अर्थ नहीं देखता, जैसा कि यह है, लेकिन यह लंबे समय तक रहेगा। आपका ध्यान देने के लिए धन्यवाद।आप यहां परियोजना डाउनलोड कर सकते हैं: http: //xn--c1abmgrdmpk4e.xn--p1ai/files/opengl.zip

हम रूबिक का क्यूब एमुलेटर लिखते हैं