ओपनजीएल/सामान्य ग्राफिक्स के लिए सर्वश्रेष्ठ गतिशील भाषाएं

Question

ग्राफिकल प्रोग्राम लिखने के लिए सबसे परिपक्व और अच्छी तरह से समर्थित समाधान कौन से हैं?

मैं ओपनजीएल/जीएलयूटी के साथ सी ++ का उपयोग कर रहा हूं, लेकिन एक और अधिक लचीला और अभिव्यक्तिपूर्ण दृष्टिकोण का प्रयास करना चाहता हूं।

रूबी और प्रसंस्करण? पायथन और ओजीआरई? आपके लिए क्या काम अच्छी तरह से काम किया है?

Answer 1

यह देखते हुए कि आप सी ++ से परिचित हैं, तो आप Lua को आज़मा सकते हैं। लुआ एक गतिशील भाषा है जिसे किसी भी सी/सी ++ प्रोग्राम में एम्बेड किया जा सकता है। यह खेल उद्योग में बहुत लोकप्रिय है।

Answer 2

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

मैंने एक वर्ष या तीन साल पहले रुबी/ओपनजीएल के साथ प्रयोग करना शुरू किया और यह चारों ओर खेलने के लिए काफी आसान था।

आप को गंभीरता से (जो भी कारण के लिए) एक परियोजना का निर्माण करना चाहते हैं, तो मैं

• मूल भाषा में यह लागू हो जाता है (या क्रम उस पर चलाता है) का एक संयोजन के आधार पर एक रूपरेखा उठा सुझाव देंगे
• गतिशील भाषा इंजन या क्रम
• ढांचे

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

विकिपीडिया में list of game engines है। कई मानदंडों के आधार पर मैंने jMonkeyEngine (v2) के साथ एक प्रोजेक्ट शुरू किया और राइनो (एक जेवीएम जावास्क्रिप्ट कार्यान्वयन) से काम करना और नियंत्रण करना आसान पाया।

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

उस समय सी # करना, मैंने प्लेटफॉर्म पर चलने के लिए डॉटनेट और मोनो दोनों को लक्षित करने वाली परियोजनाओं/ढांचे को देखा था, लेकिन विकास (ताओ?) ढांचे और मोनो लुआ बाइंडिंग के विकास को विकसित करने में बहुत परेशानी थी। शायद चीजें बदल गई हैं।

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

Answer 3

आप देख रहे हैं कि ओपन आउट-ऑफ-द-बॉक्स (कोई बाहरी बाइंडिंग) का समर्थन गतिशील भाषाओं के लिए इन की कोशिश:

• PLT Scheme
• Spark-Scheme
• Factor

Answer 4

मैं विचार करने के विकल्प के रूप में PyOpenGL के साथ पायथन का उल्लेख करना चाहता हूं।

यदि आप ओपनजीएल से पहले ही परिचित हैं, तो PyOpenGL मूल रूप से पाइथन में लिखा गया एक एपीआई रैपर है। मैं पहले आश्चर्यचकित था कि कोड पाइथन और सी ++ में कैसा दिखता है। इस तरह (ध्यान दें मैं भी Pyglet उपयोग कर रहा हूँ):

def setup_render(self): 
    '''First rendering setup''' 
    glClearColor(0.0, 0.0, 0.0, 1.0) 
    glClearDepth(1.0)  

    glEnable(GL_LIGHTING)  
    glEnable(GL_DEPTH_TEST)  
    glEnable(GL_ALPHA_TEST)   
    glEnable(GL_CULL_FACE)    

def draw(self, time_passed): 
    '''Drawing events''' 
    if self.has_exit: 
     pyglet.app.exit() 
     return 

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) 
    glUseProgram(self.shader.program) 
    self.set_lights() 

    # Draw objects here 
    glTranslate(0, 0, -10) 
    glScale(5.0, 5.0, 5.0) 
    glutSolidSphere(1, 16, 16) 

देखें कैसे समान यह सी ++ कोड के लिए है।

मैं पाइथन में जल्दी से PyOpenGL लेने में सक्षम था, और 200 लाइनों के तहत एक Quaternion कक्षा लागू किया। यदि आप पाइथन से सहज हैं, तो मैं इसे जांचने के लिए आपको अनुशंसा करने में संकोच नहीं करूंगा।

वैसे, PyOpenGL's API documentationofficial one से कहीं अधिक पठनीय है।

Answer 5

मेरा व्यक्तिगत सुझाव अगर आप परिपक्वता और समर्थन के बाद हैं Processing - बहुत लचीला, खुला स्रोत, अच्छी तरह से प्रलेखित और great community। सिंटेक्स सी-जैसा है इसलिए आपको इसे चुनने में कोई कठिनाई नहीं होनी चाहिए।

एक और अधिक अत्याधुनिक समाधान जो बहुत ही आशाजनक लग रहा है (लेकिन मुझे अभी तक परीक्षण करने के लिए गोल नहीं मिला है!) Penumbra - एक गतिशील कार्यात्मक प्रोग्रामिंग शैली में ओपनजीएल विकास के लिए क्लोजर लाइब्रेरी है।

(enable :light0) 
(push-matrix 
    (translate 0 0 -10) 
    (draw-quads 
    (vertex 0 0 0) 
    (vertex 0 1 0) 
    (vertex 1 1 0) 
    (vertex 1 0 0))) 

ध्यान दें कि Clojure मैक्रो चतुराई के बहुत सारे करने के लिए धन्यवाद, यह स्वतः और पारदर्शी सही समय पर परिवर्तन मैट्रिक्स पॉपिंग तरह बातें संभालती है: यहाँ एक सुंदर छोटा-सा स्निपेट है। अन्य चीजें जो अच्छी लगती हैं वे GPGPU समर्थन जैसी चीजें हैं। रैकेट (पूर्व पीएलटी योजना) के लिए लिंक के लिए