हास्केल पर ओपनजीएल के माध्यम से ग्राफिक्स

परिचय

एक राय है कि हास्केल नर्ड्स-गणितज्ञों के लिए एक भाषा है। बेशक, ये सभी स्टीरियोटाइप हैं, लेकिन वास्तव में इस पर बहुत कम ट्यूटोरियल हैं, जो अध्ययन में कुछ हद तक बाधा डालते हैं। विशेष रूप से कुछ ऐसे हैं जहां वास्तविक अनुप्रयोग लिखे गए हैं (उल्लेखनीय रियल वर्ल्ड हास्केल यहां खड़ा है, जो हालांकि, कुछ गड़बड़ है)। इसलिए, हास्केल - ड्राइंग ग्राफिक्स में कम से कम प्रबुद्ध क्षेत्रों में से एक के बारे में इस ट्यूटोरियल को लिखने के लिए विचार आया। मैं इसे विस्तृत बनाने की कोशिश करूंगा, लेकिन यह माना जाता है कि पाठक हास्केल की मूल बातें से परिचित है, विशेषकर भिक्षुओं की अवधारणा के साथ। यदि नहीं, तो मैं इस विषय को पढ़ने की सलाह देता हूं , साथ ही उन पुस्तकों को भी देता हूं जो स्किमिनोक इस पर टिप्पणियों में सलाह देता है।
डिस्क्लेमर: प्रयोगात्मक पुस्तकालय के साथ काम किया जाएगा। इसलिए हर तरह की गड़बड़ियों पर आश्चर्य न करें, ताकि सब कुछ काम करे।

क्या हम?

स्थापना

मेरी विनम्र राय में, यह बहुत ही निरर्थक है। खासकर मेरे जैसे नॉन-सिस्टम इंजीनियरों के लिए।

लिनक्स (उबंटू 10.10)

मुझे पता नहीं है कि ओपनजीएल के कौन से संस्करण मूल रूप से शिप किए गए हैं, लेकिन मैंने यहां से जीएचसी और हास्केल प्लेटफार्म को डाउनलोड और संकलित किया है । इस प्रक्रिया में, मुझे कुछ पुस्तकालयों को डाउनलोड करना पड़ा (मुझे ठीक-ठीक याद है, मुझे freeglut3-dev की आवश्यकता थी)। हम एक परीक्षण के मामले को संकलित करते हैं, और - एक बमर। विंडो को दूसरे विभाजन के लिए दिखाया गया है और छोटा किया गया है। मैं नॉटिलस से लॉन्च करता हूं - यह काम करता है। Irc- चैनल पर, कोई भी इस सवाल का जवाब नहीं देना चाहता था :) अगर कोई भी कारण बता सकता है, तो कृपया टिप्पणियों में पूछें।

विंडोज 7 (x86_64)

परंपरागत रूप से अधिक उपद्रव। इस ट्यूटोरियल ने इंस्टॉलेशन में बहुत मदद की।
1. हम मिनग्व डालते हैं। इंस्टॉल करते समय, न्यूनतम इंस्टॉलेशन का चयन करें। मुख्य बात यह है कि MinGW बनाने के लिए नहीं है।

2. हम MSys डालते हैं । हम स्थापित करने के लिए सहमत हैं, जवाब दें कि मिनगॉव स्थापित है, और इसके लिए पथ इंगित करें। हम msys शुरू करते हैं, हम कंसोल में लिखते हैं "gcc --version" और हम आश्वस्त हैं कि सब कुछ काम करता है।

3. यहां से फ्रीग्लूट डाउनलोड करें , इसे __MinGW/1.0/home/_ ( __MinGW/1.0/home/_ - __MinGW/1.0/home/_ में अनपैक करें । उपयोगकर्ता नाम आपके विंडोज खाते का नाम है। Msys को चलाने और लिखने के बाद:

 cd freeglut-2.4.0/src/ gcc -O2 -c -DFREEGLUT_EXPORTS *.c -I../include gcc -shared -o glut32.dll *.o -Wl,--enable-stdcall-fixup,--out-implib,libglut32.a -lopengl32 -lglu32 -lgdi32 -lwinm 

स्वाभाविक रूप से, यदि निर्देशिका का नाम अलग-अलग है, तो उसे कमांड में बदलना होगा :)
आउटपुट दो फाइलें हैं - glut32.dll और libglut32.a। Dll को _/Windows/System कॉपी करें। यदि आपने मानक हास्केल-प्लेटफॉर्म स्थापित किया है, तो वह सब है (और libglut32.a की आवश्यकता नहीं होगी)। यदि आपके लिए सब कुछ अलग-अलग है (उदाहरण के लिए जीएचसी को अलग से स्थापित किया गया था), तो मैं उसी ट्यूटोरियल का संदर्भ देता हूं ताकि विषय को न बढ़ाया जाए।

महत्वपूर्ण: या आप बस काबाल का उपयोग कर सकते हैं।

सत्यापन के लिए आप इस कोड का उपयोग कर सकते हैं। यदि सब कुछ काम करता है, तो आप एक छायांकित क्षेत्र देखेंगे।

व्यावहारिक काम

हास्केल और ओपनजीएल बहुत सामंजस्यपूर्ण नहीं हैं, क्योंकि लगभग सभी क्रियाएं मोनाड्स के माध्यम से की जाती हैं। चर के एनालॉग्स का भी उपयोग किया जाता है, जिसे ऑपरेटर $ = के माध्यम से एक मूल्य सौंपा जाता है। आइए एक आदिम कार्यक्रम को लिखने और संकलित करने का प्रयास करें जो एक लाल पृष्ठभूमि के साथ एक खिड़की बनाता है।
नोट: लिनक्स में सामान्य रूप से रन के तहत संकलन, लिनक्स के तहत कमांड ghc -package GLUT -lglut Program.hs -o Program

 import Graphics.UI.GLUT import Graphics.Rendering.OpenGL main = do getArgsAndInitialize createAWindow "Red Window" mainLoop createAWindow windowName = do createWindow windowName displayCallback $= display display = do clearColor $= Color4 1 0 0 1 clear [ColorBuffer] flush 

इसलिए, हम एक पूर्वनिर्धारित रंग के साथ स्क्रीन को साफ करते हैं। यदि खिड़की साफ नहीं की जाती है, तो काम के माहौल का एक स्क्रीनशॉट इसमें दिखाई देगा। यह Color4 प्रकार को ध्यान देने योग्य है - यह आरजीबीए प्रारूप में रंग सेट करता है, 0 से 1 तक GLFloat (जो कि सबसे साधारण 32-बिट फ्लोट है) प्रत्येक रंग के लिए जिम्मेदार है। मौन श्रृंखला हमेशा फ्लश फ़ंक्शन के लिए कॉल के साथ समाप्त होती है। यह सुनिश्चित करता है कि कार्रवाई की पूरी श्रृंखला ग्राफिक्स कार्ड पर भेजी जाए। परिणाम:

यह खिड़की में कुछ प्रदर्शित करने का समय है। यह रेंडरप्रिमेटिक फ़ंक्शन के माध्यम से किया जाता है, जिसमें 2 तर्क होते हैं: आदिम का प्रकार और कोने का निर्देशांक। 3 डी अंतरिक्ष में कार्यक्षेत्रों को परिभाषित किया गया है

 vertex (Vertex3 xyz) 

या

 vertex$Vertex3 xyz 

OpenGL एक कार्टेशियन समन्वय प्रणाली का उपयोग करता है:

आइए एक काले रंग की पृष्ठभूमि पर 3 नीले बिंदुओं को आकर्षित करने का प्रयास करें:

 import Graphics.UI.GLUT import Graphics.Rendering.OpenGL main = do getArgsAndInitialize createAWindow "Points Window" mainLoop createAWindow windowName = do createWindow windowName displayCallback $= display display = do clear [ColorBuffer] currentColor $= Color4 0 0.3 1 1 renderPrimitive Points( do vertex (Vertex3 (0.1::GLfloat) 0.5 0) vertex (Vertex3 (0.1::GLfloat) 0.2 0) vertex (Vertex3 (0.2::GLfloat) 0.1 0)) flush 

जैसा कि आप देख सकते हैं, रेंडरिंग के लिए वर्धमान को मोनाड में रखा गया है - एक से अधिक शीर्ष खींचने का एकमात्र तरीका। परिणाम:

चूँकि हम लंबों के साथ काम करते हैं, न कि बिंदुओं के साथ, तो यह बिंदुओं के सभी त्रिभुजों को कोने में बदलना तार्किक है:

 map (\(x,y,z)->vertex$Vertex3 xyz) 

और परिणामी साधुओं को अनुक्रम का उपयोग करके एक में परिवर्तित करें। हालाँकि, एक अधिक स्वादिष्ट सिन्सेटिक चीनी है - mapM_, जिसमें ये दोनों कार्य शामिल हैं:

 mapM_ (\(x,y,z)->vertex$Vertex3 xyz) 

मुट्ठी भर चीनी के साथ एक सहायक मॉड्यूल बनाएं:

 module PointsRendering where import Graphics.UI.GLUT import Graphics.Rendering.OpenGL import Random renderInWindow displayFunction = do (progName,_) <- getArgsAndInitialize createWindow "Primitive shapes" displayCallback $= displayFunction mainLoop getRand::IO Float getRand = getStdRandom( randomR (0,1)) displayPoints points primitiveShape = do renderAs primitiveShape points flush renderAs figure ps = renderPrimitive figure(makeVertx ps) makeVertx = mapM_ (\(x,y,z)->vertex$Vertex3 xyz) exampleFor primitiveShape = renderInWindow (displayExmplPoints primitiveShape) displayExmplPoints primitiveShape = do clear [ColorBuffer] r <- getRand currentColor $= Color4 0 0.3 r 1 displayPoints myPoints primitiveShape myPoints = [(0.2,-0.4,0::GLfloat) ,(0.46,-0.26,0) ,(0.6,0,0) ,(0.6,0.2,0) ,(0.46,0.46,0) ,(0.2,0.6,0) ,(0.0,0.6,0) ,(-0.26,0.46,0) ,(-0.4,0.2,0) ,(-0.4,0,0) ,(-0.26,-0.26,0) ,(0,-0.4,0) ] 

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

 import PointsRendering import Graphics.UI.GLUT import Graphics.Rendering.OpenGL main = exampleFor Polygon 

परिणाम:

बहुभुज के बजाय, आप ADT PrimitiveMode से किसी अन्य मान को स्थानापन्न कर सकते हैं

 data PrimitiveMode = Points | Lines | LineLoop | LineStrip | Triangles | TriangleStrip | TriangleFan | Quads | QuadStrip | Polygon deriving ( Eq, Ord, Show ) 

एक निष्कर्ष के बजाय

यह लेख HOpenGL के माध्यम से मानचित्रण की मूल बातें पर मुश्किल से छुआ है। पर्दे के पीछे अन्य आदिम (जैसे एक सर्कल), परिवर्तन, 3 डी, और बहुत कुछ थे। यदि समुदाय में दिलचस्पी है, तो मैं इस विषय पर कुछ और लेख लिख सकता हूं।

सूत्रों का कहना है

• हॉस्पेल - 3 डी ग्राफिक्स हास्केल के साथ - स्वेन एरिक पानिट्ज़
• आधिकारिक HOpenGL ट्यूटोरियल