English  Español  Português  Français  Italiano  Deutsch  Nederlands  Svenska  Dansk  Suomi  Norsk  Русский  Polski  Română  Български  Hrvatski  Česky  中国  中國  日本語  한국어  Ελληνική  हिन्दी  العربية 

C# OpenGL इंटरफ़ेस

ऑपरेटिंग सिस्टम के लिए Windows

Colin Fahey

मैं C# OpenGL अंतरफलक (CSGL12) के भीतर सभी C# कंप्यूटर कोड का लिखा.

मैं C# OpenGL अंतरफलक (CSGL12) के भीतर सार्वजनिक क्षेत्र में होने की सभी C# कंप्यूटर "कोड की घोषणा."

इसलिए, कंप्यूटर कोड किसी भी उद्देश्य के लिए इस्तेमाल किया जा सकता है (वाणिज्यिक या निजी), भुगतान के बिना, प्रतिबंध के बिना दायित्व के बिना, और मूल लेखक को स्वीकार करने के बिना.

इस कोड को संशोधित किया जा सकता है या भाग reused, प्रतिबंध के बिना, और दायित्व के बिना, और मूल लेखक को स्वीकार करने के बिना.

उदाहरण के कार्यक्रमों में शामिल हैं एक छोटी मात्रा में कंप्यूटर कोड ( विशेष , "shader कंप्यूटर code ) अन्य लोगों द्वारा लिखित ."  इस तरह के कोड को ही इंटरफ़ेस के भीतर नहीं है और trivially हटाया जा सकता है.  इस तरह के कोड केवल बनाने के लिए और प्रयोग shader प्रोग्राम के इंटरफ़ेस का उपयोग करने की सादगी "को प्रदर्शित" करने के लिए है. 

"CSGL12" कोड C# कंप्यूटर फ़ाइलों का जो OpenGL ग्राफिक्स पुस्तकालय के लिए एक अंतरफलक औजार एक संग्रह (वर्ष 2007 तक के लिए OpenGL के सभी एक्सटेंशन) के Windows ऑपरेटिंग सिस्टम के लिए भी शामिल है.

इस "CSGL12" संग्रह में C# कंप्यूटर कोड फ़ाइलें आसान एक "Form" "System.Windows.Forms.Form" की (एक उदाहरण) के साथ किसी भी C# / .NET सॉफ्टवेयर के लिए ड्राइंग यह OpenGL जोड़ने के लिए करते हैं.

कंप्यूटर कोड फ़ाइलों की "CSGL12" संग्रह एक फाइल "CSGL12Control.cs" है, जो एक वर्ग "CSGL12Control", "System.Windows.Forms.Control" से व्युत्पन्न नाम परिभाषित नाम शामिल हैं.  "CSGL12Control" के प्रत्येक उदाहरण एक स्वतंत्र OpenGL ड्राइंग क्षेत्र का प्रतिनिधित्व करता है.  यह बहुत ही एक Form System.Windows.Forms.Form की (एक उदाहरण) करने के लिए CSGL12Control के कई उदाहरण हैं जोड़ने के लिए आसान है.

इस कोड को केवल यह है कि .NET 2.0 Framework (Windows 2000, Windows XP, Windows Vista, Windows 7) समर्थन Windows ऑपरेटिंग सिस्टम के लिए है

कोड (एक मुक्त संकलक) "Microsoft Visual C# 2008 Express Edition" का उपयोग करते हुए, या इसी तरह की C# compilers संकलित किया जा सकता है.

इस कोड को "[X] Allow unsafe code" कि नकल कार्यों इस्तेमाल किया जा सकता है छवि डेटा अनुकूलित विकल्प इसलिए चुना निर्माण के साथ निर्मित किया जा रहा की आवश्यकता है.  यदि आप आसानी से कि "unsafe" विकल्प और उन्हें निष्क्रिय अगर वांछित या आवश्यकता की जरूरत को C# कोड के भागों की पहचान करने में सक्षम हो जाएगा एक विशेषज्ञ C# प्रोग्रामर हैं.  छवि डेटा नकल 10 गुना तेजी "unsafe" कोड का विकल्प से अधिक है, और इसी वजह से इस तरह के कोड प्रयोग किया जाता है का उपयोग कर रहा है.  यदि आप एक DLL कि सभी "unsafe" कोड का होता है, तो एक परियोजना का उपयोग करता है कि DLL को "unsafe" विकल्प के साथ निर्मित किया जा रहा है, और की आवश्यकता नहीं होती तो क्या आप अनुमान कर सकते हैं कि किसी भी निर्माण अतिरिक्त संकेत नहीं करता है एक परियोजना में "unsafe" विकल्प के अभाव सुरक्षा (क्योंकि कई DLL फ़ाइलें जो परोक्ष रूप या स्पष्ट प्रोग्राम द्वारा असुरक्षित कोड) "का उपयोग किया" जाता है. 

इस कोड को संकलित किया जा सकता है और किसी भी निम्नलिखित के द्वारा प्रयोग किया है:

Microsoft Visual C# 2008 Express Edition
Microsoft Visual Studio 2008
Microsoft .NET 3.5 SDK
SharpDevelop
Mono Project

कोड (के माध्यम से सबसे OpenGL एक्सटेंशन प्रदान करता है वर्ष 2007), "vertex shaders" और "pixel shaders" सहित.

कोड 1570 कार्यों OpenGL से संबंधित प्रदान करता है:

 336  GL  functions
  51  GLU functions
  19  WGL functions
1164  extensions

इस कोड को विभिन्न प्रकार के पैरामीटर के साथ 1570 कार्य के कुछ वैकल्पिक भिन्नरूपों प्रदान करता है, सुविधा के लिए.

कोड OpenGL के लिए 3244 स्थिर से अधिक परिभाषित करता है.

कोड इसे कई OpenGL ड्राइंग संदर्भों के लिए संभव बनाता है, सभी animating स्वतंत्र रूप से, किसी भी "Form" पर.

एक "CSGL12Control" पर क्लिक करके यह "अनुमति इनपुट ध्यान" देता बाद कीबोर्ड और माउस पहिया इनपुट.  कर्सर क्लिकें और आंदोलनों जब कर्सर "CSGL12Control" का एक उदाहरण के आयताकार क्षेत्र के भीतर है प्राप्त कर रहे हैं.

यह कोड कैसे C# और .NET में कुछ आम OpenGL कार्य करने के लिए प्रदर्शन करने के लिए कार्य शामिल हैं.

कोड "class GL" में वर्णमाला क्रम में "GL.cs" में, यह आसान यदि कोई लगातार या समारोह है लापता (जो संभावना नहीं है, एक्सटेंशन वर्ष 2007 के बाद अपनाया के अलावा निर्धारित करने के लिए बना) सभी OpenGL स्थिर और कार्यों सूचियों.

इस उदाहरण कार्यक्रमों कैसे एक Bitmap के लिए ड्राइंग GDI+ करना, और फिर कैसे की प्रतिलिपि करने के लिए दिखाता है कि Bitmap एक OpenGL संरचना करने के लिए.

इससे पाठ और अन्य GDI+ ड्राइंग क्षमताओं में योगदान के लिए एक दृश्य OpenGL .

इस अद्यतन किया जा सकता है और GDI+ Bitmap अपलोड करने के लिए एक OpenGL बुनावट जितनी बार एक बार फ्रेम प्रति OpenGL .

इस उदाहरण कार्यक्रमों जबकि कार्यक्रम चला रहा है कि कैसे कई अलग "pixel shader programs" में से चयन करने के लिए दिखा.

इस उदाहरण कार्यक्रम कैसे छवि फ़ाइलें (JPG, BMP, GIF, PNG) करने के लिए OpenGL buffers लिखने के लिए दिखा.

प्रेस Shift + 0 (पाली-शून्य) छवि फ़ाइलों को OpenGL बफर लिखने के लिए.

इस उदाहरण कोड कैसे में एक DLL फाइल करने के लिए, और फिर उस DLL एक अन्य परियोजना के लिए फाइल, (संदर्भ के प्रति संवेदनशील कोड पूरा) अक्सर और persistently बनने से "IntelliSense" के साथ (जैसे, Microsoft Visual C# 2008 Express Edition, आदि) के Microsoft कोड संपादकों रोका जा सकता है जोड़ने "GL.cs" संकलन शो अनुत्तरदायी (बार बार कई सेकंड के लिए, संपादक को पूरी तरह से बेकार बना) रोक.  जब तक एक व्यक्ति को संपादक की सुस्ती बर्दाश्त करने को तैयार है फ़ाइल "GL.cs" बाद सीधे किसी भी परियोजना में शामिल एक Microsoft कोड संपादक द्वारा संपादित किया जा रहा, व्यावहारिक नहीं है.  इस समस्या को और Microsoft Visual Studio 2003, 2005, 2008, प्रभावित किया है शायद 2010 संस्करण को प्रभावित करेगा, भी. 

इस उदाहरण कोड एक "Form" पर "CSGL12Control" के कई उदाहरणों के प्रयोग को दर्शाता है.

इस उदाहरण कोड कि Windows के डेस्कटॉप roams "एक 3D" अवतार बनाने के लिए कोड शामिल हैं.

इस परियोजना "CSGL12DLL" पैदा नाम एक DLL "CSGL12DLL.dll" जो "class GL" शामिल हैं (इस C# फ़ाइल "GL.cs" में) परिभाषित नाम फ़ाइल.

में एक DLL फाइल करने के लिए, और फिर का उपयोग कर "class GL" डाल कि DLL अन्य परियोजनाओं में इस्तेमाल "class GL" है, IntelliSense सुविधा के साथ सभी Microsoft कोड संपादकों के साथ एक चरम समस्या से बचने में मदद करता है.  एक परियोजना GL.cs सीधे में C# फ़ाइल पूरी तरह अनुत्तरदायी बनने के लिए और लगभग लगातार IntelliSense सुविधा की अक्षमता के लिए (और इस तथ्य के कारण है कि IntelliSense स्पष्ट संपादक का मुख्य कार्यक्रम धागा ब्लाकों unusable के IntelliSense सुविधा के साथ किसी भी Microsoft कोड संपादक कारण का उपयोग करना होगा ). 

यदि आप, तो आप बस सीधे अपने परियोजनाओं में फाइल "GL.cs" शामिल कर सकते हैं कि Microsoft द्वारा (जैसे, "SharpDevelop", "MonoDevelop", आदि) का उत्पादन नहीं है एक C# कोड संपादक का प्रयोग कर रहे हैं, और आप की संभावना कम हो जाएगा "CSGL12DLL.dll" का उपयोग करने से कोई लाभ हासिल करने के लिए. 

इस परियोजना "CSGL12Control" पैदा नाम एक DLL "CSGL12Control.dll" जो "class CSGL12Control" शामिल हैं (इस C# फ़ाइल "CSGL12Control.cs" में) परिभाषित नाम फ़ाइल.

में एक DLL फाइल करने के लिए, "class CSGL12Control" लगा कि "Control" (यानी, एक वर्ग "System.Windows.Forms.Control" से प्राप्त) Microsoft Visual C# 2008 Express Edition के "Toolbox" करने के लिए (और इसी प्रकार के C# संपादक) जोड़ा जा करने के लिए सक्षम बनाता है.  इस "Toolbox" में "CSGL12Control" करने के बाद यह आसान करने के लिए एक व्यक्ति को "Designer" में एक "Form" करने के लिए (जैसे, बस का चयन करने के लिए और "Toolbox" एक "Form" से "CSGL12Control" का एक उदाहरण खींचें) के कर्सर का उपयोग कर सकते हैं एक व्यक्ति "CSGL12Control" का एक उदाहरण जोड़ने के लिए बनाता है. 

इस "CSGL12Control" उद्देश्य एक OpenGL ड्राइंग संदर्भ सफल हुआ है.  "CSGL12Control" के कई उदाहरण एक "Form" पर एक समय में होना कर सकते हैं.

इस परियोजना "CSGL12Example1" "CSGL12Example1.exe" नाम पर एक प्रोग्राम निष्पादन योग्य फ़ाइल (EXE) पैदा नाम.  यह कार्यक्रम CSGL12Control का एक उदाहरण प्रदर्शित करने के लिए और एक घन OpenGL का उपयोग कर आकर्षित "CSGL12DLL.dll" और "CSGL12Control.dll" का उपयोग करता है.

यह कार्यक्रम (, ईंट, लकड़ी, fractal और कार्टून) चार "अलग "pixel shaders" के प्रयोग को दर्शाता है." 

यह कार्यक्रम भी "GDI+", एक .NET ड्राइंग पुस्तकालय, के एक "Bitmap" वस्तु को पाठ और अन्य आकार आकर्षित करने के लिए उपयोग दर्शाता है (एक "GDI+" ऑब्जेक्ट), और फिर OpenGL में एक "texture" करने के लिए, इस प्रकार की छवि तैयार की अनुमति देता है कि "Bitmap" से छवि डेटा की प्रतिलिपि "GDI+" द्वारा ड्राइंग OpenGL में प्रदर्शित करने के लिए.  क्योंकि OpenGL "GDI+" में और इसी प्रकार के 2D libaries ड्राइंग मिली सुविधाओं के 2D ड्राइंग के कई क्षमता का अभाव यह बहुत उपयोगी है.

इस परियोजना "CSGL12Example2" "CSGL12Example2.exe" नाम पर एक प्रोग्राम निष्पादन योग्य फ़ाइल (EXE) पैदा नाम.  यह कार्यक्रम प्रत्येक जिनमें से एक घन OpenGL का उपयोग कर खींच CSGL12Control के दो उदाहरण हैं, प्रदर्शित करने के लिए "CSGL12DLL.dll" और "CSGL12Control.dll" का उपयोग करता है.

इस कार्यक्रम के "Form" पर एक "SplitContainer" "Control" है.  प्रत्येक "SplitContainer" के दो क्षेत्रों के CSGL12Control का एक उदाहरण है.  इस प्रकार, एक व्यक्ति CSGL12Control के दो उदाहरण के बीच विभाजन की स्थिति समायोजित कर सकते हैं.  यह CSGL12Control के लचीलेपन को दर्शाता है.

एक CSGL12Control के उदाहरणों की घटना handlers का एक सेट करने के लिए "CSGL12Example2Handler1.cs", जो "CSGL12Example1" उदाहरण "CSGL12Example1Handler.cs" परियोजना के रूप में एक ही कोड का उपयोग करता है की एक उदाहरण में घटनाओं को भेजता है.  इसलिए, एक CSGL12Control एक चयनित "pixel shader" के साथ चार उपलब्ध "pixel shaders" में से एक घन दिलाता के उदाहरणों की. 

CSGL12Control के अन्य उदाहरण घटना handlers का एक सेट करने के लिए "CSGL12Example2Handler2.cs", अगर एक छवि "image.jpg" नहीं मिला है, जो फ़ाइल नाम (या एक बिसात पैटर्न एक घन "एक बनावट छवि" का उपयोग कर खींच का एक उदाहरण में) की घटनाओं भेजता है. 

इस परियोजना "CSGL12Avatar" "CSGL12Avatar.exe" नाम पर एक प्रोग्राम निष्पादन योग्य फ़ाइल (EXE) पैदा नाम.  यह कार्यक्रम कि Windows डेस्कटॉप क्षेत्र roams एक 3D अवतार आकर्षित करने के लिए सक्षम पारदर्शिता रंग के साथ एक घन एक सीमा के बिना "Form" करने पर OpenGL का उपयोग करते "हुए, आधारित" आकर्षित करने के लिए "CSGL12DLL.dll" और "CSGL12Control.dll" का उपयोग करता है.

यह हिल avatar क्लिक किया जा सकता है और एक नए स्थान के कर्सर का उपयोग करने के लिए घसीटा.  डबल इसे गायब कर देगा ने avatar क्लिक.  हालांकि कोड केवल एक घन दिलाता, OpenGL अन्य चीजें आकर्षित करने के लिए इस्तेमाल किया जा सकता है. 

इस अवतार कार्यक्रम के "एकाधिक उदाहरण" शुरू किया जा सकता है.  इस प्रकार, कई स्वतंत्र "अवतार" उदाहरण एक ही समय में Windows डेस्कटॉप घूम सकते.  यह मनोरंजक है.  एक विशेषज्ञ C# प्रोग्रामर कई ऐसे अवतार उदाहरणों की गतिविधि का समन्वय करने के लिए उपायों की "खोज का आनंद" सकता है. 

दुर्भाग्य से, जिस पर पारदर्शिता के साथ Window वस्तु स्क्रीन पर अद्यतन किया जाता है, जिस पर OpenGL दर अधिक आकर्षित कर सकते हैं दर की तुलना में धीमी गति में होती है.  इस "अवतार" ही अपडेट 10 बार प्रति सेकंड.  अगर यह सुधार किया जा सकता है मैं नहीं जानता. 

इस निर्देशिका "CSGL12BuiltExecutableExamplesForReference" सभी उदाहरण परियोजनाओं के द्वारा उत्पादित फ़ाइलें DLL फ़ाइलें और EXE नाम शामिल है.  ये फाइलें एक संदर्भ के रूप में है, तो यह है कि फाइल को तुरंत, भले ही एक व्यक्ति की क्षमता को प्रदान की C# कोड से विभिन्न परियोजनाओं संकलन करने के लिए नहीं है, का परीक्षण किया जा सकता है प्रदान की जाती हैं.

इस निर्देशिका "CSGL12UsefulCode" कि जो OpenGL के साथ सामान्य बैठक संचालन करना चाहते लोगों के लिए उपयोगी हो सकता है C# फाइल का नाम शामिल है.  इस निर्देशिका भी DLL फ़ाइलें शामिल हैं "CSGL12DLL.dll" और "CSGL12Control.dll" सुविधा के लिए.

इस कोड में है कि निर्देशिका Color4f, Vector3f, Matrix4x4f, Triangle, Mesh, ImageData, Texture, ShaderProgram, आदि जैसे विभिन्न प्रकार के class, परिभाषित  इस कोड को यथोचित, लेकिन कुशल है कोड ही लोगों को उनके अपने implementations को विकसित करने के लिए प्रेरित करना है.

C# कंप्यूटर कोड फ़ाइलों की "CSGL12" संग्रह फाइल में निम्नलिखित चित्र में दिखाया शामिल हैं:

इस "CSGL12" सॉफ्टवेयर भी ("CSGL12DLL.dll" और "CSGL12Control.dll") के चित्र में दिखाया गया कि दो DLL फाइल बनाने के लिए परियोजनाएं शामिल हैं.  वे दो DLL फ़ाइलें इसे और अधिक कार्यक्रम बनाने के लिए सुविधाजनक बनाने के लिए बनाया जा सकता है कि प्रयोग OpenGL, लेकिन यह भी सीधे कार्यक्रम केवल C# फ़ाइलों का उपयोग कर बनाने के लिए संभव है.

C# कंप्यूटर कोड फ़ाइलों की "CSGL12" संग्रह और "namespace CSGL12" परिभाषित के "class" प्रकार निम्न चित्र में दिखाया गया:

एक प्रोग्राम है कि केवल "class GL" का उपयोग करके बनाया जा सकता है (सीधे इस C# फ़ाइल GL.cs का उपयोग कर या जो भी "class GL" समाहित DLL फ़ाइल CSGL12DLL.dll का उपयोग करके) OpenGL ड्राइंग करता है.  हालांकि, का उपयोग कर "class CSGL12Control" (सीधे, CSGL12Control.cs या जो CSGL12Control.dll भी "class CSGL12Control" समाहित DLL फ़ाइल का उपयोग कर C# फ़ाइल का उपयोग करते हुए) द्वारा OpenGL एक Form (System.Windows.Forms.Form करने के लिए ड्राइंग) जोड़ने आसान बनाता है और सुविधाजनक.

इस C# वर्गों Color4f, CSGL12Support, ImageData, ..., इस चित्र के नीचे केवल सुविधा के लिए देने की पेशकश कर रहे हैं.  उन वर्गों आसान है कि OpenGL का उपयोग आकर्षित कार्यक्रम बनाने के लिए करते हैं.  लेकिन, आप पहले से ही वर्गों है कि उन वर्गों में आपरेशन प्रदर्शन, या आप समान कक्षाओं कि अलग या अधिक कुशलतापूर्वक संचालन प्रदर्शन का निर्माण करने के लिए चुन सकते हैं हो सकता है.  वे कक्षा में एक विशेष कोड डिजाइन और कार्यान्वयन के उदाहरण के रूप में देने की पेशकश कर रहे हैं. 

निम्नलिखित चित्र कैसे एक System.Windows.Forms.Form के साथ एक कार्यक्रम OpenGL के साथ बैठक करने के लिए एक भी "CSGL12Control" का उपयोग कर सकते हैं दर्शाता है.  इस चित्र को विभिन्न CSGL12 कार्यक्रम बनाने के लिए प्रयोग किया जाता फ़ाइलों को दिखाता है.

(1) शुरू Microsoft Visual C#.

(2) मेनू चुनें "File" -> "New Project..."  में.

(3) कि, "Windows Forms Application" का चयन होता है कि "New Project" संवाद बॉक्स में, और इस कार्यक्रम के लिए, और प्रेस "OK" एक नाम चुनें.

(4) तुरन्त "File" -> "Save All" चुन कर उस "Solution" बचाओ.  शीर्षक "Save Project" के साथ एक संवाद बॉक्स, आप इस परियोजना के नाम, निर्देशिका स्थान निर्धारित करने के लिए सक्षम करने, और इस परियोजना "के" लिए "हल" का नाम दिखाई देगा.  ताकि आप अगले अनुदेश के लिए तैयार हैं निर्देशिका स्थान याद रखें.  प्रेस को "Save" बटन परियोजना को बचाने के लिए.

(5) कॉपी निर्देशिका (यानी, निर्देशिका "Form1.cs", "Form1.Designer.cs", "Program.cs" आदि फाइल युक्त) ने नई परियोजना के स्रोत कोड युक्त फ़ाइलों को "CSGL12" सॉफ्टवेयर में निर्देशिका "CSGL12UsefulCode" से सभी फाइलें ऐसी है कि फाइल "CSGL12DLL.dll", "CSGL12Control.dll", "Color4f.cs" , "CSGL12Support.cs", आदि, नई परियोजना फाइलों "Form1.cs", आदि के साथ कर रहे हैं

(6) Microsoft Visual C# में, "CSGL12" C# जोड़ने की परियोजना के लिए फ़ाइलें.  मेनू में, चुनें "Project" -> "Add Existing Item...", और "Add Existing Item" संवाद बॉक्स में, सभी CSGL12 सॉफ्टवेयर ("Color4f.cs", "CSGL12Support.cs", "ImageData.cs", ...).  से C# फाइल का चयन करें

(7) Microsoft Visual C# में, "DLL फाइल" करने के लिए संदर्भ जोड़ने "CSGL12DLL.dll" और "CSGL12Control.dll".  मेनू में, चुनें "Project" -> "Add Reference...", और "Add Reference" संवाद बॉक्स में, इस "Browse" टैब चुनें और फाइल का चयन "CSGL12DLL.dll" और "CSGL12Control.dll" परियोजना स्रोत फाइल निर्देशिका में से है, और प्रेस "OK". 

(8) Microsoft Visual C# में, "Toolbox" करने के लिए "CSGL12Control" जोड़ें.  मेनू चुनें "Tools" -> "Choose Toolbox Items..."  में.  कि लगता है कि "Choose Toolbox Items" संवाद बॉक्स, में, "Browse..."  बटन दबाएँ और स्रोत कोड फ़ाइलों के साथ इस परियोजना निर्देशिका करने के लिए जाते हैं, और "CSGL12Control.dll" चुनें.  प्रेस को "OK" बटन.

(9) Microsoft Visual C# में, "Toolbox" देखें.  मेनू चुनें "View" -> "Toolbox" में.  इस "Toolbox" में, खंड "General" नाम करने के लिए, जाओ और इस मद "CSGL12Control" नाम ढूँढ.  इस कर्सर का प्रयोग, क्लिक करें आइटम "CSGL12Control" नाम और "Form" को "Design" ध्यान में रखते हुए इसे खींचें. 

(10) Microsoft Visual C# में, "Form" "Design" देखने में "Form" पर "CSGL12Control" उदाहरण और उसकी चौड़ाई और ऊंचाई समायोजित चाल.  यदि आप प्रोग्राम विंडो आकार में परिवर्तन के अनुसार आकार बदलने के लिए नियंत्रण चाहते हैं "Properties" पैनल में, "Top, Bottom, Left, Right" को शामिल करने के लिए "Anchor" मूल्य निर्धारित किया है.

(11) Microsoft Visual C# में, जिससे कि यह "unsafe" कोड का उपयोग कर सकते हैं इस परियोजना के गुण बदलते हैं.  मेनू चुनें "Project" -> "[project] Properties..."  में.  चुनें कि इस संवाद बॉक्स प्रकट होता है, तो टैब "Build" नाम चुनें और चेक बॉक्स "[X] Allow unsafe code" नाम की जाँच करें.  बंद परियोजना गुण संवाद बॉक्स.

(12) Microsoft Visual C# में, एक नए C# इस परियोजना के लिए फ़ाइल जोड़ें.  मेनू चुनें "Project" -> "Add New Item..."  में.  इस संवाद बॉक्स "Add New Item" नाम में, "Class" नाम टेम्पलेट, चुनें और "CSGL12MyHandler.cs" जैसे नए वर्ग का प्रकार, के लिए एक नाम चुनें, और फिर "Add" बटन दबाएँ.  उदाहरण परियोजना "CSGL12Example1" नाम पर, फाइल "CSGL12Example1Handler.cs" नाम पर, कैसे "CSGL12MyHandler.cs" का कोड लिखा होना चाहिए का एक उदाहरण के रूप में देखो. 

(13) Microsoft Visual C# में, "Solution Explorer", "Form1" पर क्लिक करें में.  मेनू चुनें "View" -> "Code" (या प्रेस F7, या "Form1" पर राइट क्लिक करें और चुनें "View Code" में.  फ़ाइल "Form1.cs" में कोड संपादक में दिखाई देंगे.  फ़ाइल "Form1.cs" में कोड की संशोधित परियोजना में फाइल "CSGL12Example1Form.cs" में इस कोड को "CSGL12" सॉफ्टवेयर में शामिल "CSGL12Example1" समान होने के लिए.  विशेष रूप से,, और फिर "Form" पर "CSGL12Control" का उदाहरण की विभिन्न घटनाओं के लिए घटना handlers के रूप में है कि वर्ग उदाहरण के तरीकों को जोड़ने अपने घटना प्रहस्तक वर्ग (जैसे, "CSGL12MyHandler") का एक उदाहरण के लिए एक चर बनाएँ. 

(14) Microsoft Visual C# में, संकलन और कार्यक्रम पर अमल.  यदि आप इस कार्यक्रम का हिस्सा करना चाहते हैं, तो आप ("CSGL12DLL.dll" और "CSGL12Control.dll") में निष्पादन योग्य फ़ाइल (*.exe) के साथ दो DLL फ़ाइलों को शामिल करना चाहिए. 

यह खंड इस परियोजना CSGL12DLL.dll और CSGL12Control.dll को DLL "फाइल करने के लिए संदर्भ" जोड़ने के लिए Microsoft Visual C# 2008 Express Edition का उपयोग करने के चित्र शामिल हैं.

मेनू चुनें "Project" -> "Add Reference..."  में.  या, इस "Solution Explorer" पैनल और चयन "Add Reference..."  में दाएँ क्लिक करें "References" मद, जैसा कि निम्नलिखित छवि में दिखाया गया है. 

इस "Add Reference..."  विकल्प, एक संवाद बॉक्स "Add Reference" दिखाई देगा नाम चुनने के बाद.  यह संवाद बॉक्स में, इस "Browse" टैब चुनें और "CSGL12DLL.dll" और "CSGL12Control.dll", जैसा कि निम्नलिखित छवि में दिखाया गया कि DLL फ़ाइलों का चयन करें, और फिर बटन "OK" लेबल दबाएँ. 

बटन "OK", गायब हो जाएगा "Add Reference" संवाद बॉक्स, और DLL फ़ाइलें "CSGL12DLL.dll" और "CSGL12Control.dll" के "Solution Explorer" में "References" शाखा में प्रदर्शित होगी, जैसा कि निम्न चित्र में दिखाया लेबल दबाव के बाद.

यह खंड) को "Toolbox" करने के लिए इतना CSGL12Control जोड़ने के लिए है कि एक व्यक्ति आसानी से मूलभूत रूप से "Designer" में एक "Form" (Shift+F7 करने के लिए CSGL12Control की घटनाओं को जोड़ सकते हैं Microsoft Visual C# 2008 Express Edition के उपयोग की तस्वीरें भी शामिल हैं.

मेनू चुनें "View" -> "Toolbox" में.  इस "Toolbox" में, खंड "General" नाम करने के लिए, जैसा कि निम्न चित्र में दिखाए जाते हैं.

इस "Toolbox" के भीतर कहीं दायाँ क्लिक करें.  चुनें कि, जैसा कि निम्नलिखित छवि में दिखाया गया लगता है कि संदर्भ मेनू में विकल्प "Choose Items...".

वैकल्पिक रूप से, इस मेनू में, चुनें चुनें "Tools" -> "Choose Toolbox Items...".

इस "Choose Toolbox Items" संवाद बॉक्स, जैसा कि निम्न चित्र में दिखाया प्रकट करना चाहिए.

इस "Choose Toolbox Items" संवाद बॉक्स में, "Browse" बटन दबाएँ.  कि लगता है कि "Open" संवाद बॉक्स में, जैसा कि निम्नलिखित छवि में, और फिर "OK" बटन प्रेस दिखाया के DLL फ़ाइल "CSGL12Control.dll" चुनें. 

इस "CSGL12Control" मद अब "Choose Toolbox Items" संवाद बॉक्स में, जैसा कि निम्न चित्र में दिखाया प्रकट करना चाहिए.  प्रेस को "OK" बटन.

इस "CSGL12Control" मद अब "Toolbox" में, जैसा कि निम्न चित्र में दिखाया प्रकट करना चाहिए. 

यह खंड एक "Form" करने के लिए "Toolbox" का उपयोग करके CSGL12Control का एक उदाहरण जोड़ने के लिए Microsoft Visual C# 2008 Express Edition के उपयोग की तस्वीरें भी शामिल हैं. 

मेनू में, चुनें "View" -> "Designer" (Shift+F7 डिफ़ॉल्ट रूप से).  इस "Solution Explorer" में या, डबल क्लिक करें एक "Form*.cs" फ़ाइल.  या फिर दाएँ क्लिक करें "Solution Explorer" और चयन "View Designer" में एक "Form*.cs" फ़ाइल.  उनमें से एक तीन तरीकों का उपयोग कर, एक "Form" के लिए "Designer" विंडो दिखाई देनी चाहिए.

मेनू चुनें "View" -> "Toolbox" में.  इस "Toolbox" में, खंड "General" नाम के पास जाओ.  एक आइटम "CSGL12Control" वहाँ है, के रूप में निम्नलिखित छवि में दिखाया प्रकट करना चाहिए नाम. 

इस कर्सर का प्रयोग, क्लिक करें आइटम "CSGL12Control" नाम और "Form" को "Designer" में खींचें.  "CSGL12Control" का एक उदाहरण के "Form" के रूप में निम्नलिखित छवि में दिखाया गया पर दिखाई देना चाहिए. 

इस "Form" "Designer" दृश्य में, "Form" पर "CSGL12Control" के उदाहरण कदम है और इसकी चौड़ाई और ऊंचाई समायोजित करें. 

इस "Form" पर "CSGL12Control" के उदाहरण पर क्लिक करें का चयन करने के.  फिर, "Properties" पैनल में, ताकि "CSGL12Control" के आकार प्रोग्राम विंडो आकार में परिवर्तन करने की प्रतिक्रिया में बदल जाएगा "Top, Bottom, Left, Right" को शामिल करने के लिए "Anchor" मूल्य निर्धारित किया है.  आप यह भी है (यानी, "(Name)" के लिए मूल्य) अपने कोड (जैसे, "mCSGL12Control" या "mCSGL12Control1", आदि) के लिए कोई उपयुक्त करने के लिए स्वत: डिफ़ॉल्ट से "CSGL12Control" के उदाहरण (जैसे, "csgL12Control") के लिए चर नाम बदलना चाहते हो सकती है. 

निम्नलिखित छवि को "Form" "Designer" दृश्य और "Properties" पैनल प्रदर्शित करता है.

निम्नलिखित चित्र कैसे "CSGL12Control" के दो उदाहरण एक System.Windows.Forms.Form करने के लिए OpenGL के साथ एक कार्यक्रम में बैठक करने के लिए जोड़ा जा सकता है की एक उदाहरण दिखाता है.

पिछले भाग में दिए गए निर्देशों का पालन एक "Form" करने के लिए "CSGL12Control" का एक उदाहरण जोड़ने के लिए.  तो, बस "Toolbox" से "Form" करने के लिए एक दूसरे "CSGL12Control" जोड़ने के लिए "CSGL12Control" का एक दूसरा उदाहरण खींचें. 

"CSGL12Control" के प्रत्येक उदाहरण अपने ही चर नाम होगा.  "CSGL12Control" के प्रत्येक उदाहरण अपने ही जुड़े घटना प्रहस्तक वर्ग हो सकता है, या यह एक एकल प्रहस्तक वर्ग प्रकार के विशिष्ट उदाहरण का उपयोग कर सकते हैं. 

अध्ययन के उदाहरण परियोजना "CSGL12Example2" कैसे दो उदाहरण "CSGL12Control" उनके घटनाएँ हो सकता है जानने के लिए विशिष्ट OpenGL ड्राइंग कार्यों के साथ कस्टम घटना प्रहस्तक वर्गों के दो विशिष्ट उदाहरण के लिए भेजा. 

"CSGL12Example2" एक "SplitContainer" "Control" में "CSGL12Control" के प्रत्येक उदाहरण है उदाहरण कार्यक्रम, बस जिसमें "CSGL12Control" के उदाहरण का उपयोग किया जा सकता है एक तरह से प्रदर्शित करने के लिए.  हालांकि, "CSGL12Control" के उदाहरण के बजाय सीधे "Form" करने पर रखा जा सकता है. 

निम्नलिखित पूर्ण C# कोड की फाइल "CSGL12Example1Form.cs", जो उदाहरण कार्यक्रम का हिस्सा है में निहित है "CSGL12Example1". 

यह कोड यहाँ से एक सरल उदाहरण के रूप में प्रस्तुत किया है कि कैसे CSGL12Control की एक मिसाल पैदा की जा सकती है और एक "Form" द्वारा इस्तेमाल किया.

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 CSGL12;








namespace CSGL12Example1
{




    public partial class CSGL12Example1Form : Form
    {




        public CSGL12Example1Handler        mCSGL12Example1Handler;
        private System.Windows.Forms.Timer  mTimer;








        public CSGL12Example1Form()
        {
            InitializeComponent();



            mCSGL12Example1Handler = new CSGL12Example1Handler();
            mCSGL12Control1.OpenGLStarted += new CSGL12Control.DelegateOpenGLStarted( mCSGL12Example1Handler.OpenGLStarted );
            mCSGL12Control1.KeyDown += new KeyEventHandler(mCSGL12Example1Handler.KeyDown);
            mCSGL12Control1.KeyUp += new KeyEventHandler(mCSGL12Example1Handler.KeyUp);
            mCSGL12Control1.MouseDown += new MouseEventHandler(mCSGL12Example1Handler.MouseDown);
            mCSGL12Control1.MouseUp += new MouseEventHandler(mCSGL12Example1Handler.MouseUp);
            mCSGL12Control1.MouseMove += new MouseEventHandler(mCSGL12Example1Handler.MouseMove);
            mCSGL12Control1.MouseWheel += new MouseEventHandler(mCSGL12Example1Handler.MouseWheel);
            mCSGL12Control1.Paint += new PaintEventHandler(mCSGL12Example1Handler.Paint);




            // Use a timer to trigger drawing at the desired frame rate.
            //
            // Windows timers are not very precise.  Also, if we call wglSwapIntervalEXT(1)
            // and we specify in the global OpenGL control panel that OpenGL drawing
            // should wait for vertical sync (vsync) of the display, then the frame
            // rate would be limited to 60 frames/second or 75 frames/second, for example,
            // and our program would have to draw each frame in less than 1/60 seconds
            // (16.6 milliseconds) or less than 1/75 seconds (13.3 milliseconds),
            // otherwise the drawn frame would be forced to wait one or more full
            // frame durations before appearing on the screen.  Therefore, it would
            // be best to have the timer interval somewhat shorter than a full frame
            // interval, to ensure that even if there is a slight delay in responding
            // to the timer event we will have at least one timer event per display
            // frame interval.
            //
            // Theoretically, a timer interval of 16 milliseconds would be short enough
            // to sustain a frame rate of 62.5 frames/second, and would seemingly have
            // a corresponding rate sufficient to sustain 60 frames/second in the case
            // of a vertical-sync limited drawing rate for OpenGL.  However, in simple
            // experiments on a system with a 2.5 GHz Core 2 Duo CPU with an nVidia
            // GeForce 8600M GS with 512 MB, I found that a 16-millisecond Windows
            // timer interval results in a 33 frames/second OpenGL frame rate (where
            // vertical-sync locking is enabled, and the display refresh rate is
            // 60 frames/second).  So, despite theoretically being slightly more rapid
            // than necessary to maintain a 60 frames/second drawing rate, a Windows
            // timer with an interval of 16-milliseconds isn't quite rapid enough to
            // ensure drawing soon enough to be ready for each display refresh; hence
            // the rather significantly lower than desired frame rate of 33 frames/second.
            //
            // Here are the OpenGL drawing frame rates (limited to 60 Hz vertical sync)
            // I observed on a particular computer for particular Windows timer intervals:
            //
            //    18-millisecond timer interval   -->   31 frames/second OpenGL drawing
            //    17-millisecond timer interval   -->   31 frames/second OpenGL drawing
            //    16-millisecond timer interval   -->   33 frames/second OpenGL drawing
            //    15-millisecond timer interval   -->   60 frames/second OpenGL drawing
            //    14-millisecond timer interval   -->   60 frames/second OpenGL drawing
            //
            // So, it seems like choosing a Windows timer interval only a couple of
            // milliseconds shorter than the theoretical 16.6 millisecond interval
            // corresponding to a 60 frames/second rate is enough for this program to
            // submit each new frame in time for the next display refresh.
            //
            // However, computers with slower CPUs or slower GPUs might benefit from
            // an even shorter Windows timer interval, to ensure that drawing will
            // happen soon enough for the next display refresh.
            //
            // Some displays are set to refresh at 75 frames/second, which corresponds
            // to a frame duration of 13.3 milliseconds.  We will aim for this drawing
            // rate, and we will subtract a few milliseconds from the Windows timer
            // interval to ensure that we receive and process the timer event soon
            // enough to submit the frame in time for the next display refresh.
            // Meanwhile, we will choose the Windows timer interval such that it isn't
            // absurdly short, lest future faster computers actually manage to draw
            // at that wasteful rate.
            //
            // Choosing a Windows timer interval of 10 milliseconds seems like it will
            // reliably be able to trigger OpenGL frame drawing in time to keep up with
            // a 75 frames/second display (13.3 millisecond frame duration), while
            // only causing the OpenGL drawing to happen at a maximum rate of
            // 100 frames/second in the unlikely scenario of a very fast computer
            // actually being able to draw frames at that rate (given the overhead of
            // C#, etc).

            mTimer = new System.Windows.Forms.Timer();
            mTimer.Interval = 10; // 10-millisecond interval
            mTimer.Tick += new EventHandler(PrivateTimerTickEventHandler);
            mTimer.Start();




            // Set focus to a control so that it can immediately accept input

            mCSGL12Control1.Focus();




            // Also, whenever the form becomes activated, set focus to the main
            // control on the form.  The following sets up an event handler for
            // that purpose.

            this.Activated += new EventHandler(PrivateActivatedEventHandler);




            // We want to preview dialog keys (most importantly, the cursor
            // keys: up, down, right, left) so we can forward such events to
            // the appropriate child control.

            this.KeyPreview = true;
        }








        void PrivateTimerTickEventHandler(object sender, EventArgs e)
        {
            if (false == DesignMode)
            {
                mCSGL12Control1.Invalidate();
            }
        }








        private void PrivateActivatedEventHandler(object sender, EventArgs e)
        {
            // When this form becomes activated, after some time of not
            // being active, set input focus to a GL control on the form.
            if (false == mCSGL12Control1.Focused)
            {
                mCSGL12Control1.Focus();
            }
        }








        // Cursor keys (up,down,left,right) need to be specially captured
        // and forwarded to the control.
        // CAUTION: The KeyPreview property of this Form must be set to 'true'
        // for the following method to be called.

        protected override bool ProcessDialogKey(Keys keyData)
        {
            if
                (
                   (keyData == Keys.Up)
                || (keyData == Keys.Down)
                || (keyData == Keys.Left)
                || (keyData == Keys.Right)
                )
            {
                KeyEventArgs e = new KeyEventArgs(keyData);

                if (true == mCSGL12Control1.Focused)
                {
                    mCSGL12Example1Handler.KeyDown(mCSGL12Control1, e);
                }
                else
                {
                    // The CSGL12Control does not have focus.
                    // Let's simply drop the dialog key event.  The user
                    // may have focus on a different control.
                }


                return (true);
            }

            return base.ProcessDialogKey(keyData);
        }




    }




}

सूचना है कि सदस्य चर "mCSGL12Example1Handler" एक class का एक उदाहरण का उल्लेख करने की घोषणा की है "CSGL12Example1Handler" नाम.  यह वर्ग इस दस्तावेज़ के एक बाद के भाग में वर्णित किया जाएगा.  सूचना है कि "CSGL12Example1Form" के लिए निर्माता के "multicast delegates" विभिन्न घटनाओं "CSGL12Control" का एक उदाहरण द्वारा उत्पन्न के साथ जुड़े को "CSGL12Example1Handler" के उदाहरण के तरीकों कहते हैं.  इसका मतलब यह है कि जब "CSGL12Control" के उदाहरण विभिन्न घटनाओं उत्पन्न इसका मतलब है, उन घटनाओं "CSGL12Example1Handler" का उदाहरण है (यानी, "mCSGL12Example1Handler") के विभिन्न तरीकों के कारण होगा लागू किया जाना है.

सूचना है कि सदस्य चर "mTimer" एक class का एक उदाहरण का उल्लेख करने की घोषणा की है "System.Windows.Forms.Timer" नाम.  यह उद्देश्य एक समारोह "PrivateTimerTickEventHandler" हर 10 milliseconds नाम आह्वान करने के लिए प्रयोग किया जाता है.  इस समारोह "PrivateTimerTickEventHandler" "CSGL12Control" का उदाहरण है (यानी, "mCSGL12Control1") की है कि खुद को आकर्षित करने के लिए कि "Control" कारण एक विधि फोन का नाम रखा.  यह कैसे "CSGL12Control" का एक उदाहरण एक अनुमानित दर से एनिमेटेड कर सकता है.

"class CSGL12Example1Form" की परिभाषा का ही हिस्सा C# में "CSGL12Example1Form.cs" नाम दर्ज होता है.  "class CSGL12Example1Form" की परिभाषा का दूसरा हिस्सा एक C# "CSGL12Example1Form.Designer.cs" नाम फ़ाइल में प्रकट होता है.  हालांकि नाम तर्ज "*.Designer.cs" मिलान के साथ फाइल आमतौर पर बनाया जाता है और एक C# संपादक के सुचित्रित "Form Designer" खिड़की केवल द्वारा संशोधित, यह भी बनाने के लिए संभव है और संशोधित ऐसी C# एक पाठ संपादक का उपयोग करके फ़ाइलें. 

निम्नलिखित पूर्ण C# कोड की फाइल "CSGL12Example1Form.Designer.cs", जो उदाहरण कार्यक्रम का हिस्सा है में निहित है "CSGL12Example1". 

namespace CSGL12Example1
{
    partial class CSGL12Example1Form
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.mCSGL12Control1 = new CSGL12.CSGL12Control();
            this.SuspendLayout();
            //
            // mCSGL12Control1
            //
            this.mCSGL12Control1.Anchor = ((System.Windows.Forms.AnchorStyles)
                      ((((System.Windows.Forms.AnchorStyles.Top
                        | System.Windows.Forms.AnchorStyles.Bottom)
                        | System.Windows.Forms.AnchorStyles.Left)
                        | System.Windows.Forms.AnchorStyles.Right)));
            this.mCSGL12Control1.BackColor = System.Drawing.SystemColors.Control;
            this.mCSGL12Control1.Location = new System.Drawing.Point(12, 12);
            this.mCSGL12Control1.Name = "mCSGL12Control1";
            this.mCSGL12Control1.Size = new System.Drawing.Size(640, 480);
            this.mCSGL12Control1.TabIndex = 0;
            this.mCSGL12Control1.Text = "CSGL12Control1";
            //
            // CSGL12Example1Form
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(664, 504);
            this.Controls.Add(this.mCSGL12Control1);
            this.Name = "CSGL12Example1Form";
            this.Text = "CSGL12Example1";
            this.ResumeLayout(false);

        }

        #endregion

        private CSGL12.CSGL12Control mCSGL12Control1;
    }
}

सूचना है कि इस C# कोड को चर "mCSGL12Control1" है, जो "class CSGL12.CSGL12Control" का एक उदाहरण के लिए (यानी, "class CSGL12Control" "namespace CSGL12" में) संदर्भित की घोषणा शामिल है.  यह उदाहरण बनाया है और इस समारोह "InitializeComponent" में विन्यस्त. 

पिछले अनुभाग एक "Form" के लिए कि "CSGL12Control" का एक उदाहरण शामिल C# कोड दिखाया.  इस C# कोड घटना handlers के रूप में विभिन्न घटनाओं "CSGL12Control" के उदाहरण द्वारा उत्पन्न करने के लिए "CSGL12Example1Handler" नाम एक "class" के तरीकों जोड़ें. 

यहाँ "CSGL12Control" के दिलचस्प घटनाओं की एक सूची है, और इस प्रकार "delegate" उन घटनाओं से जुड़े:

OpenGLStarted     CSGL12Control.DelegateOpenGLStarted

KeyDown           System.Windows.Forms.KeyEventHandler
KeyUp             System.Windows.Forms.KeyEventHandler

MouseDown         System.Windows.Forms.MouseEventHandler
MouseUp           System.Windows.Forms.MouseEventHandler
MouseMove         System.Windows.Forms.MouseEventHandler
MouseWheel        System.Windows.Forms.MouseEventHandler

Paint             System.Windows.Forms.PaintEventHandler

केवल "OpenGLStarted" घटना एक प्रकार की घटना की "CSGL12Control" करने के लिए विशिष्ट है.

अन्य सभी घटनाओं की घटनाओं System.Windows.Forms मानक हैं , जिनकी कुछ मानकों घटना handlers होना चाहिए ( Forms में विनिर्दिष्ट किसी भी दस्तावेज़ ) .

इस "OpenGLStarted" और "Paint" घटनाओं OpenGL बैठक के लिए सबसे महत्वपूर्ण घटना है.

"OpenGLStarted" से पहले इस घटना के पहले ही लागू है "Paint" दुहाई घटना है .

इसलिए , "OpenGLStarted" घटना में जोड़ा जाना चाहिए प्रहस्तक के नियंत्रण से पहले के नियंत्रण में करने की कोशिश करने का अवसर ही रंग , अन्यथा इस घटना से एक बार प्राप्त नहीं किया जाएगा .

यह सुविधा केवल एक घटना है , और अनदेखा किया जा सकता है .

लेकिन , एक प्रहस्तक जोड़ने के लिए इस घटना के लिए यह संभव बनाता है प्रहस्तक करने के लिए कुछ कोड प्रारंभन है कि एक समय पर निर्भर करता है OpenGL का उपयोग करने के लिए तैयार किया जा रहा है .

( OpenGL प्रयोग नहीं किया जा सकता जब तक की खिड़की से मौजूद है और प्रदर्शन करने के लिए तैयार है विंडो में अपना पहला रंग है .

इसलिए , "OpenGLStarted" घटना के पुर्जों क्रमादेशक के खतरे से OpenGL का उपयोग करने के प्रयास के बाद भी जल्दी ही इस कार्यक्रम की शुरुआत .

) यह काफी एक "Paint" प्रहस्तक तर्क में जोड़ने के लिए एक एक समय initialization है, "CSGL12Control" के OpenGL संदर्भ का उपयोग करना आसान है.

"OpenGLStarted" इस घटना के रूप में एक सुविधा की पेशकश की है .

निम्नलिखित पूर्ण C# कोड की फाइल "CSGL12Example1Handler.cs", जो उदाहरण कार्यक्रम का हिस्सा है में निहित है "CSGL12Example1". 

यह कोड यहाँ से एक सरल उदाहरण के रूप में प्रस्तुत किया है कि कैसे इन घटनाओं "CSGL12Control" का एक उदाहरण द्वारा उत्पन्न OpenGL का उपयोग करने के लिए आकर्षित संभाला जा सकता है.

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Imaging;




// This program requires "references" to the following:
//
//         CSGL12DLL.dll       (defines CSGL12.GL)
//         CSGL12Control.dll   (defines CSGL12.CSGL12Control)

using CSGL12;








namespace CSGL12Example1
{




    public class CSGL12Example1Handler
    {




        private Mesh mMesh;
        private ShaderProgram mShaderProgram1;
        private ShaderProgram mShaderProgram2;
        private ShaderProgram mShaderProgram3;
        private ShaderProgram mShaderProgram4;
        private ShaderProgram mShaderProgramSelected;

        private Bitmap mHUDBitmap;
        private Texture mHUDTexture;
        private Font mFont1;
        private Font mFont2;
        private Font mFont3;
        private Font mFont4;
        private Pen mPen1;
        private Brush mBrush1;

        private double mViewDistance = 800.0;
        private double mViewAzimuthDegrees = 0.0;
        private double mViewAltitudeDegrees = 0.0;

        private double mViewAzimuthDegreesVelocity = 9.0;
        private double mViewAltitudeDegreesVelocity = 5.0;

        private Point mMouseClientPositionStart;
        private double mViewAzimuthDegreesStart = 0.0;
        private double mViewAltitudeDegreesStart = 0.0;
















        public CSGL12Example1Handler()
        {
            mMesh = new Mesh();

            mShaderProgram1 = new ShaderProgramMandelbrotSet();
            mShaderProgram2 = new ShaderProgramWood();
            mShaderProgram3 = new ShaderProgramBrick();
            mShaderProgram4 = new ShaderProgramCartoon();

            mShaderProgramSelected = mShaderProgram1;

            mHUDBitmap = new Bitmap(512, 512, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
            mHUDTexture = new Texture();

            mFont1 = new Font("Verdana", 36.0f);
            mFont2 = new Font("Verdana", 24.0f);
            mFont3 = new Font("Courier New", 16.0f);
            mFont4 = new Font("Courier New", 10.0f);

            mPen1 = new Pen(Color.Red, 3.0f);

            mBrush1 = new SolidBrush(Color.FromArgb(64, 128, 128, 140));
        }
















        public void OpenGLStarted( CSGL12Control csgl12Control )
        {
            GL gl = csgl12Control.GetGL();

            if (null == gl) { return; }




            // Load shaders and set variables

            if (true == gl.bglCreateProgramObjectARB)
            {
                if (null != mShaderProgram1)
                {
                    mShaderProgram1.ShaderProgramCreate(gl);
                }
                if (null != mShaderProgram2)
                {
                    mShaderProgram2.ShaderProgramCreate(gl);
                }
                if (null != mShaderProgram3)
                {
                    mShaderProgram3.ShaderProgramCreate(gl);
                }
                if (null != mShaderProgram4)
                {
                    mShaderProgram4.ShaderProgramCreate(gl);
                }
            }




            // Create cube mesh

            mMesh = new Mesh();
            mMesh.BuildCube(400.0f);




            // Create a texture

            mHUDTexture.CreateTextureFromBitmap(gl, mHUDBitmap, true);




            // To prevent "tearing" (irregular streaks) due to swapping buffers at
            // arbitrary times relative to the vsync times, we indicate that we wish
            // to wait for vsync before swapping buffers.
            // This request applies when the display driver control panel -- in the
            // OpenGL settings area -- is set to let the application decide whether or
            // not to wait for vsync.  Otherwise, the driver control panel overrides
            // any request made here.

            if (true == gl.bwglSwapIntervalEXT)
            {
                gl.wglSwapIntervalEXT(1);
            }
        }
















        public void Paint(object sender, PaintEventArgs e)
        {
            if (null == sender) { return; }
            if (false == (sender is CSGL12Control)) { return; }




            CSGL12Control csgl12Control = (sender as CSGL12Control);
            GL gl = csgl12Control.GetGL();




            int clientWidth = csgl12Control.ClientRectangle.Width;
            int clientHeight = csgl12Control.ClientRectangle.Height;

            if (clientWidth <= 0)
            {
                clientWidth = 1;
            }

            if (clientHeight <= 0)
            {
                clientHeight = 1;
            }




            // Set the viewport

            gl.glViewport(0, 0, clientWidth, clientHeight);




            // Clear the viewport

            gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
            gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);




            // Basic drawing conditions

            gl.glEnable(GL.GL_DEPTH_TEST);
            gl.glDepthFunc(GL.GL_LEQUAL);
            gl.glEnable(GL.GL_CULL_FACE);
            gl.glCullFace(GL.GL_BACK);
            gl.glFrontFace(GL.GL_CCW);





            // PROJECTION matrix, typically for perspective correction or orthographic projection

            gl.glMatrixMode(GL.GL_PROJECTION);
            gl.glLoadIdentity();

            double aspectRatio = 1.0;

            if (0 != clientHeight)
            {
                aspectRatio = ((double)(clientWidth) / (double)(clientHeight));
            }

            double verticalFieldOfViewAngle = 60.0;

            gl.gluPerspective
            (
                verticalFieldOfViewAngle, // Field of view angle (Y angle; degrees)
                aspectRatio, // width/height
                0.1, // distance to near clipping plane
                64000.0 // distance to far clipping plane
            );




            // MODELVIEW matrix, typically used to transform individual models

            gl.glMatrixMode(GL.GL_MODELVIEW);
            gl.glLoadIdentity();

            // Preserve current matrix for the active matrix stack (in this case the MODELVIEW matrix)

            gl.glPushMatrix();




            if (mViewAltitudeDegreesVelocity != 0.0)
            {
                if (mViewAltitudeDegrees > 70.0)
                {
                    mViewAltitudeDegrees = 70.0;
                    mViewAltitudeDegreesVelocity *= -1.0;
                }
                else if (mViewAltitudeDegrees < -70.0)
                {
                    mViewAltitudeDegrees = -70.0;
                    mViewAltitudeDegreesVelocity *= -1.0;
                }

                mViewAzimuthDegrees += mViewAzimuthDegreesVelocity * csgl12Control.GetPreviousFrameDurationSeconds();
                mViewAltitudeDegrees += mViewAltitudeDegreesVelocity * csgl12Control.GetPreviousFrameDurationSeconds();
            }




            Vector3f from =
                new Vector3f
                (
                    (float)(mViewDistance * Math.Cos(mViewAltitudeDegrees * (Math.PI / 180.0)) * Math.Sin(mViewAzimuthDegrees * (Math.PI / 180.0))),
                    (float)(mViewDistance * Math.Sin(mViewAltitudeDegrees * (Math.PI / 180.0))),
                    (float)(mViewDistance * Math.Cos(mViewAltitudeDegrees * (Math.PI / 180.0)) * Math.Cos(mViewAzimuthDegrees * (Math.PI / 180.0)))
                );
            Vector3f to = new Vector3f(0.0f, 0.0f, 0.0f);
            Vector3f up = new Vector3f(0.0f, 1.0f, 0.0f);

            Matrix4x4f camera = Matrix4x4f.LookAt(from, to, up);




            float[] matrix = new float[16];

            matrix[0] = camera.m11;
            matrix[1] = camera.m21;
            matrix[2] = camera.m31;
            matrix[3] = 0.0f;

            matrix[4] = camera.m12;
            matrix[5] = camera.m22;
            matrix[6] = camera.m32;
            matrix[7] = 0.0f;

            matrix[8] = camera.m13;
            matrix[9] = camera.m23;
            matrix[10] = camera.m33;
            matrix[11] = 0.0f;

            matrix[12] = camera.m14;
            matrix[13] = camera.m24;
            matrix[14] = camera.m34;
            matrix[15] = 1.0f;




            gl.glMultMatrixf(matrix);




            if (mShaderProgramSelected != null)
            {
                mShaderProgramSelected.DemonstrateModificationOfVariables(gl, csgl12Control.GetPreviousFrameStartTimeSeconds(), csgl12Control.GetPreviousFrameDurationSeconds());
                mShaderProgramSelected.Select(gl);
            }




            // Draw model(s), using active texture or shader

            mMesh.Draw(gl);




            // If we used a shader, disable it now...

            if (true == gl.bglUseProgramObjectARB)
            {
                ShaderProgram.ShaderProgram_Select(gl, 0);
            }




            // Restore the previously-preserved matrix for the active matrix stack (in this case the MODELVIEW matrix)

            gl.glPopMatrix();




            // Demonstrate drawing text to a GDI+ Bitmap and then copying to
            // an OpenGL texture.

            DemonstrateDrawingTextToAGDIBitmapAndCopyingToAnOpenGLTexture(csgl12Control, gl);




            // Flush all the current rendering and flip the back buffer to the front.

            gl.wglSwapBuffers(csgl12Control.GetHDC());
        }
















        public void DemonstrateDrawingTextToAGDIBitmapAndCopyingToAnOpenGLTexture(CSGL12Control csgl12Control, GL gl)
        {
            bool updateOverlayImage = false;




            // The following code only enables an update of the Bitmap
            // and OpenGL texture every 64 frames, thus avoiding the
            // slowdown of performing updates every single frame.
            // HOWEVER, updating the Bitmap and OpenGL texture can be
            // done EVERY frame with acceptable speed.
            // Updates should be limited to once per frame, but the
            // logic to trigger updates can be based on when the relevant
            // text changes.

            if ((csgl12Control.GetTotalFramesDrawn() % 64) == 0)
            {
                updateOverlayImage = true;
            }




            bool showOverlayImage = true;




            if (true == updateOverlayImage)
            {
                using (Graphics g = Graphics.FromImage(mHUDBitmap))
                {
                    g.Clear(Color.FromArgb(0, Color.White));


                    g.FillEllipse(mBrush1, new Rectangle(0, 0, 256, 256));
                    g.FillEllipse(mBrush1, new Rectangle(256, 256, 256, 256));

                    PointF center = new PointF(0.5f * (256.0f + 0.0f), 0.5f * (256.0f + 0.0f));
                    PointF displacement = new PointF();
                    double fraction = csgl12Control.GetTotalElapsedTimeSeconds() * 0.1;
                    displacement.X = 128.0f * (float)Math.Cos(2.0 * Math.PI * fraction);
                    displacement.Y = 128.0f * (float)Math.Sin(2.0 * Math.PI * fraction);

                    g.DrawLine(mPen1, center, new PointF(center.X + displacement.X, center.Y + displacement.Y));

                    PointF carat = new PointF(0.0f, 0.0f);

                    String text = "";

                    text = "C# OpenGL (CSGL)";
                    g.DrawString(text, mFont1, Brushes.Black, carat);
                    carat.Y += mFont1.GetHeight();

                    text = "Здравствуйте";
                    g.DrawString(text, mFont2, Brushes.Black, carat);
                    carat.Y += mFont2.GetHeight();

                    text = "γεια σου";
                    g.DrawString(text, mFont2, Brushes.Black, carat);
                    carat.Y += mFont2.GetHeight();

                    text = "مرحبا";
                    g.DrawString(text, mFont2, Brushes.Black, carat);
                    carat.Y += mFont2.GetHeight();

                    text = "שלום";
                    g.DrawString(text, mFont2, Brushes.Black, carat);
                    carat.Y += mFont2.GetHeight();




                    carat.Y += 64.0f;

                    text = "Shift + 0: Save BMP,PNG,JPG,GIF";
                    g.DrawString(text, mFont4, Brushes.Black, carat);
                    carat.Y += mFont4.GetHeight();

                    text = "1,2,3,4  : Switch shader program";
                    g.DrawString(text, mFont4, Brushes.Black, carat);
                    carat.Y += mFont4.GetHeight();

                    carat.Y += 12.0f;

                    text = "Text : GDI+ on 512*512 Bitmap.";
                    g.DrawString(text, mFont4, Brushes.Black, carat);
                    carat.Y += mFont4.GetHeight();

                    text = "Bitmap copied to OpenGL texture.";
                    g.DrawString(text, mFont4, Brushes.Black, carat);
                    carat.Y += mFont4.GetHeight();

                    text = "Texture update once per 64 frames,";
                    g.DrawString(text, mFont4, Brushes.Black, carat);
                    carat.Y += mFont4.GetHeight();

                    text = "but more often would be OK.";
                    g.DrawString(text, this.mFont4, Brushes.Black, carat);
                    carat.Y += this.mFont4.GetHeight();

                    carat.Y += 12.0f;

                    text = String.Format("Frame:{0}", csgl12Control.GetTotalFramesDrawn());
                    text += " ";
                    text += String.Format("Time:{0:f2}", csgl12Control.GetTotalElapsedTimeSeconds());

                    double previousFrameDurationSeconds =
                        csgl12Control.GetPreviousFrameDurationSeconds();

                    if (previousFrameDurationSeconds > 1.0e-10)
                    {
                        double framesPerSecondOverall =
                            1.0 / previousFrameDurationSeconds;

                        text += " ";
                        text += String.Format("FPS:{0:f2}", framesPerSecondOverall );
                    }

                    g.DrawString(text, mFont3, Brushes.Black, carat);

                    carat.Y += mFont3.GetHeight();
                }

                mHUDTexture.UpdateTextureWithBitmapData(gl, mHUDBitmap);
            }




            if (true == showOverlayImage)
            {
                CSGL12Support.SupportDrawTextureImageUnrotatedAndOrthographically
                (
                    gl,
                    csgl12Control.ClientSize.Width,
                    csgl12Control.ClientSize.Height,
                    mHUDTexture,
                    0,
                    0, // i.e., 0 == draw TOP of image at TOP of viewport, Y-axis points DOWN
                    mHUDTexture.GetWidth(),  // glControl.ClientSize.Width, // mHUDTexture.GetWidth(),
                    mHUDTexture.GetHeight() // glControl.ClientSize.Height // mHUDTexture.GetHeight()
                );
            }
        }
















        public void KeyDown(object sender, KeyEventArgs e)
        {
            if (null == sender) { return; }
            if (false == (sender is CSGL12Control)) { return; }




            CSGL12Control csgl12Control = (sender as CSGL12Control);
            GL gl = csgl12Control.GetGL();




            if (e.KeyCode == Keys.A)
            {
            }

            if (e.KeyCode == Keys.Z)
            {
            }




            if (e.KeyCode == Keys.D1)
            {
                mShaderProgramSelected = mShaderProgram1;
            }
            if (e.KeyCode == Keys.D2)
            {
                mShaderProgramSelected = mShaderProgram2;
            }
            if (e.KeyCode == Keys.D3)
            {
                mShaderProgramSelected = mShaderProgram3;
            }
            if (e.KeyCode == Keys.D4)
            {
                mShaderProgramSelected = mShaderProgram4;
            }




            // NOTE: The only way for cursor key events (up,down,left,right)
            // to make it to this function is for the main form to implement
            // the following:
            //
            //   protected override bool ProcessDialogKey ( Keys keyData )
            //
            // and explicitly invoke this KeyDown() method with the
            // an appropriately formed KeyEventArgs instance.

            if (e.KeyCode == Keys.Up)
            {
                mViewDistance -= 10.0;
            }
            if (e.KeyCode == Keys.Down)
            {
                mViewDistance += 10.0;
            }
            if (e.KeyCode == Keys.Left)
            {
                mViewAzimuthDegrees += 1.0;
            }
            if (e.KeyCode == Keys.Right)
            {
                mViewAzimuthDegrees -= 1.0;
            }




            // Save an image of the viewport (press Shift-0 (zero)).  The following
            // code writes out the viewport in the following image formats: BMP, PNG, GIF, JPG.

            // If you only want a single format, comment out the other file write commands.
            // BMP has no compression artifacts, but the file can be quite large.
            // PNG looks good, and supports 8-bit transparancy (good for textures, etc).
            // GIF looks bad unless you build the color table intelligently (there is a
            //    neural network color table builder for GIF, in C#/.NET, that you can
            //    find on the Internet; perhaps Paint.NET uses that code); but GIF files
            //    can be quite small, and supports animation.
            // JPG looks good under most circumstances, and the file size can be quite small,
            //    but transparency is not supported.
            // So, for pixel-perfect images, where file size is not important, BMP might be appropriate.
            // For textures with transparency, PNG might be appropriate.
            // For good-looking images, and small file size, and use in Web pages, JPG might be appropriate.
            // For some purposes, with small file sizes, and use in Web pages, GIF might be appropriate.

            if ((e.KeyCode == Keys.D0) && (e.Shift == true))
            {
                DateTime now = DateTime.Now;

                String dateTimeString = String.Format("{0:d4}{1:d2}{2:d2}{3:d2}{4:d2}{5:d2}{6:d3}", now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond);

                String frameIndexString = String.Format("{0:d6}", csgl12Control.GetTotalFramesDrawn());

                String fileNameWithoutExtension = "screen" + "_" + dateTimeString + "_" + frameIndexString;

                CSGL12Support.SupportWriteViewportToImageFile(gl, fileNameWithoutExtension + ".bmp", System.Drawing.Imaging.ImageFormat.Bmp);
                CSGL12Support.SupportWriteViewportToImageFile(gl, fileNameWithoutExtension + ".png", System.Drawing.Imaging.ImageFormat.Png);
                CSGL12Support.SupportWriteViewportToImageFile(gl, fileNameWithoutExtension + ".gif", System.Drawing.Imaging.ImageFormat.Gif);
                CSGL12Support.SupportWriteViewportToImageFile(gl, fileNameWithoutExtension + ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
            }
        }
















        public void KeyUp(object sender, KeyEventArgs e)
        {
        }
















        public void MouseDown(object sender, MouseEventArgs e)
        {
            if (null == sender) { return; }
            if (false == (sender is CSGL12Control)) { return; }




            CSGL12Control csgl12Control = (sender as CSGL12Control);




            mMouseClientPositionStart = csgl12Control.PointToClient(Cursor.Position);


            mViewAzimuthDegreesStart = mViewAzimuthDegrees;
            mViewAltitudeDegreesStart = mViewAltitudeDegrees;


            if ((e.Button & MouseButtons.Left) == MouseButtons.Left)
            {
                mViewAzimuthDegreesVelocity = 0.0;
                mViewAltitudeDegreesVelocity = 0.0;
            }

            if ((e.Button & MouseButtons.Right) == MouseButtons.Right)
            {
                mViewAzimuthDegreesVelocity = 9.0;
                mViewAltitudeDegreesVelocity = 5.0;
            }
        }
















        public void MouseUp(object sender, MouseEventArgs e)
        {
            if ((e.Button & MouseButtons.Right) == MouseButtons.Right)
            {
            }
        }
















        public void MouseMove(object sender, MouseEventArgs e)
        {
            if (null == sender) { return; }
            if (false == (sender is CSGL12Control)) { return; }




            CSGL12Control csgl12Control = (sender as CSGL12Control);




            Point mouseClientPositionCurrent = csgl12Control.PointToClient(Cursor.Position);




            if ((e.Button & MouseButtons.Left) == MouseButtons.Left)
            {
                double azimuth =
                    mViewAzimuthDegreesStart
                    - (360.0 / (double)(csgl12Control.Width + 1))
                    * (double)(mouseClientPositionCurrent.X - mMouseClientPositionStart.X);

                double altitude =
                    mViewAltitudeDegreesStart
                    + (180.0 / (double)(csgl12Control.Height + 1))
                    * (double)(mouseClientPositionCurrent.Y - mMouseClientPositionStart.Y);

                double epsilon = 0.05;

                if (azimuth < (-180 + epsilon)) { azimuth = (-180 + epsilon); }
                if (azimuth > (180 - epsilon)) { azimuth = (180 - epsilon); }

                if (altitude < (-90 + epsilon)) { altitude = (-90 + epsilon); }
                if (altitude > (90 - epsilon)) { altitude = (90 - epsilon); }

                mViewAzimuthDegrees = azimuth;
                mViewAltitudeDegrees = altitude;
            }
        }
















        public void MouseWheel(object sender, MouseEventArgs e)
        {
            mViewDistance -= 0.1 * (double)e.Delta;
        }




    }




}

सूचना है कि इस समारोह "OpenGLStarted" इस उदाहरण में और एक OpenGL बुनावट "pixel shader programs" बनाने के लिए प्रयोग किया जाता है नाम.  इस कार्यक्रम के लिए, हम केवल एक बार उन संसाधनों को पैदा करने की आवश्यकता है, और यह अधिक केवल उन्हें एक बार बनाने के लिए सक्षम है. 

सूचना है कि समारोह में कोड की जाँच अगर एक WGL "extension", और मौजूद है "wglSwapIntervalEXT()" नाम समारोह "OpenGLStarted" नाम, अगर उस समारोह में मौजूद है, तो कोड की कि समारोह invokes.  यह समारोह, और कहा कि पूरे सत्र के लिए इस कार्यक्रम के संचालन को प्रभावित करता है एक राज्य सेट तो हम केवल एक बार, इसलिए हम "OpenGLStarted" समारोह में कहा कि समारोह में बुलाने की कोशिश है कि समारोह में बुलाने की जरूरत है (स्वयं को केवल एक बार, जो लागू है जब OpenGL एक विशेष "CSGL12Control" के लिए, हम उपयुक्त घटना को सौंपने के लिए "OpenGLStarted" विधि जोड़ा संभालने) शुरू किया है.

इस समारोह "Paint" सभी कोड का एनीमेशन का एक भी फ्रेम OpenGL "का उपयोग कर" आकर्षित करने के लिए नाम शामिल है.  इस "Paint" समारोह शायद 60 बार प्रति सेकंड, इस तथ्य यह है कि संबंधित "CSGL12Control" उदाहरण invalidated के कारण किया जा रहा है (फिर से "खुद को आकर्षित" करने के लिए मजबूर) उस दर पर बुलाया जाएगा.  (पिछले अनुभाग में "Form" कोड उदाहरण में है कि और कहा कि "CSGL12Control" की मिसाल बन "invalidated के कारण" वास्तविक समारोह रद्द कॉल की दर निर्धारित करता है इस घड़ी "को देखने के लिए देखो.)" 

सभी OpenGL कार्यों के "class GL" (उदाहरण: gl.gl*()) का एक उदाहरण का उपयोग कर लागू कर रहे हैं.  "class GL" का उदाहरण "CSGL12Control", जो परोक्ष रूप पहली पैरामीटर में "Paint" समारोह में संग्रहित है के उदाहरण से अर्जित की है.

सभी OpenGL स्थिर को "class" नाम निर्दिष्ट द्वारा एक और निरंतर के नाम डॉट के बाद "GL" निर्दिष्ट किया जा सकता है, अर्थात्, "GL.GL_TRIANGLES".

इस उदाहरण में OpenGL कोड पूरी तरह स्पष्ट नहीं है और समझने में आसान है, लेकिन उम्मीद है कि तुम कैसे कोड को अपने खुद के प्रयोजनों के लिए संशोधित किया जा सकता है पहचान कर सकता है.

अगर OpenGL समारोह के रूप में एक ही नाम के boolean झंडा इसी "समारोह" का उपयोग करने के लिए प्रयास करने से पहले सच है बस की जाँच करें.

इस boolean चर कि "b" के साथ OpenGL समारोह नाम के बाद शुरू होती है एक नाम है.

if (true == gl.bglCreateProgramObjectARB)
{
    // glCreateProgramObjectARB() exists and can be invoked.
    // Also, because that function is related to pixel shaders, it is very
    // likely that other functions that are required for the use of pixel
    // shaders also exist and can be invoked.

    // . . .
}

जाँच केवल विस्तार "कार्यों के लिए भी" आवश्यक है.

OpenGL 1.1 काम करता है, और सभी GLU काम करता है, और मुख्य WGL काम करता है, इस तरह की जाँच की आवश्यकता नहीं है.  हालांकि, boolean झंडे, और अस्तित्व उचित सेट कर रहे हैं, ऐसे सभी कार्य "class GL", कोर OpenGL 1.1 कार्यों सहित द्वारा प्रदान के लिए.  इस प्रकार, वहाँ है कि क्लास में सभी कार्यों की उपलब्धता की जांच करने के लिए एक सुसंगत तरीका है. 

चाहे या नहीं एक समारोह में एक एक्सटेंशन है "जानने" के प्रोग्रामर की जिम्मेदारी है.

लेकिन , suffixes समारोह का नाम , जैसे "EXT" , "ARB" , "MESA" , "NV" (NVidia) , "APPLE" , etc , विस्तार कार्य में मदद का संकेत है .

यदि "gl*()" एक समारोह में एक समारोह में "gl*ARB()" पड़ोसी या "gl*NV()" , तो इस समारोह "gl*()" शायद एक एक्सटेंशन ( जहाँ तक Windows OPENGL32.DLL का संबंध है ) .

यह जानने का लाभ केवल एक समारोह है या नहीं है कि क्या एक "एक्सटेंशन" ( Windows के संबंध में की OPENGL32.DLL ) से बचने की जाँच की जा रही है यदि कार्य करने में सक्षम उपलब्ध हैं .

आप सभी के लिए खोज कर सकते हैं OpenGL कार्यों में अपना कोड का प्रयोग किया , और फिर एक वर्णानुक्रम सूची के निर्माण के विभिन्न कार्यों का इस्तेमाल किया है .

फिर, अपनी कार्यक्रम की शुरुआत, पर बाद CSGL12Control, बस आप का उपयोग करने का इरादा सभी कार्यों के लिए सभी boolean झंडे की जाँच के OpenGLStarted प्रतिनिधि बताते हैं.

यदि आप इस कार्यक्रम को समाप्त करने के लिए यदि कोई "आवश्यक" कार्य लोग लापता हैं , तो सभी की जाँच के लिए इस तरह के कार्यों में कोड को समाप्त किया जा सकता है .

इसके अलावा , आप यह कर सकते हैं फार्म का एक समूह गैर जरूरी जांच कार्य में , और संभवतः सूचित उपयोगकर्ता किसी भी परिवर्तन की सुविधा है , और शायद छुट्टी में कोड की जाँच के आसपास बिखरे हुए हैं .

OpenGL अधिक अनुभव के साथ , आप प्राप्त कर सकते हैं जो एक तरह की अवधि बढ़ाने से संबंधित हैं ( उदाहरण : इमेजिंग , shaders , buffers , संपीड़न , ...).

इसलिए , आप यह कर सकते हैं की उपस्थिति की जाँच के लिए एक महत्वपूर्ण समारोह में और जानकारी का उपयोग करने के लिए तय है कि यदि उपसमुच्चय पूरे होने की संभावना है .

क्योंकि विभिन्न कारणों से , C# की तुलना में धीमी non-CLR C/C++ है .

C# अंततः विधानसभा देशी भाषा के लिए, बस के रूप में C/C++ के लिए, नीचे संकलित है, लेकिन, इस आश्वासन के C# भाषा और .NET CLR, सॉफ्टवेयर C# पर बनाया और .NET कुछ सॉफ्टवेयर का उपयोग कर बनाया non-CLR C/C++ की तुलना में धीमी गति में होती है की समग्र गति द्वारा बनाई जाने के कारण.

इसलिए, उच्च गति संभव हो रही मतलब के बजाय C# non-CLR C/C++ के प्रयोग से.

इसके अलावा , क्योंकि किसी भी फोन C# शामिल P/Invoke से पुस्तकालय का मूल निवासी है , एस्मा कार्यों जैसे OpenGL कार्य प्रदर्शन करने की आवश्यकता होगी कुछ समय काम में P/Invoke परत .

बहरहाल, "CSGL12" जल्दी से पर्याप्त काम करने के लिए लगता है कई वास्तविक समय के लिए इस तरह के सरल खेल, 3D दर्शक, संपादक, या 3 डी प्रस्तुतियों के लिए के रूप में ग्राफिकल प्रयोजनों, प्रयोग किया जाएगा.  यह विशेष रूप से इस काम की सबसे अगर CPU के बजाय इस GPU द्वारा किया जा रहा है वह सच है.

इस "Tao Framework" कि OpenGL जैसे कई खुले स्रोत पुस्तकालयों, OpenAL के लिए एक इंटरफेस प्रदान करता है एक बड़े C# / .NET पुस्तकालय () ऑडियो, SDL (एक गेमिंग / अनुकार मंच), Open Dynamics Engine (ODE) (भौतिकी), आदि है

इस Tao Framework पार है मंच (Windows, Linux, Mac OS X).

"CSGL12" करने के लिए एक ही OpenGL इंटरफ़ेस प्रदान करता है और Windows ऑपरेटिंग सिस्टम के लिए ही है.

इस Tao Framework एक समुदाय है.  एक व्यक्ति ने Tao Framework साथी के उपयोगकर्ताओं के साथ संचार से लाभ हो सकता है.

जिसके लिए "CSGL12" Windows कार्यक्रमों के लिए उपयोग करने के लिए आसान हो सकता है लेकिन, कई प्रयोजनों हो सकता है. 

English  Español  Português  Français  Italiano  Deutsch  Nederlands  Svenska  Dansk  Suomi  Norsk  Русский  Polski  Română  Български  Hrvatski  Česky  中国  中國  日本語  한국어  Ελληνική  हिन्दी  العربية