ओपनजीएल के साथ एंड्रॉइड के लिए एक तेज गति वाले गेम के लिए प्रतिपादन से गेम तर्क को अलग करने का सबसे अच्छा तरीका?

Question

मैं थोड़ी देर के लिए अध्ययन कर रहा हूं और थोड़ा खेल बना रहा हूं, और मैंने हाल ही में फैसला किया है कि मैं एंड्रॉइड के लिए गेम विकसित करने की कोशिश करूंगा।

मेरे लिए, देशी सी ++ कोड से एंड्रॉइड जावा में कूदना मुश्किल नहीं था, लेकिन यह मुझे यह सोचने के लिए सिरदर्द देता है कि मैं रेंडरिंग से अलग तर्क को कैसे बनाए रख सकता हूं।

मैं यहाँ के आसपास पढ़ने किया गया है और अन्य साइटों पर कि:

यह नहीं करने के लिए यकीन है कि प्रसंस्करण के लिए कोई समस्या नहीं एक और धागा इसके लिए सिर्फ इसलिए एंड्रॉयड इच्छा बनाने के लिए, बेहतर है।

कोड अर्थ कुछ इस तरह होगा:

public void onDrawFrame(GL10 gl) { 
    doLogicCalculations(); 
    clearScreen(); 
    drawSprites(); 
} 

लेकिन मुझे यकीन है कि अगर सबसे अच्छा तरीका हो सकता है नहीं कर रहा हूँ। चूंकि मुझे नहीं लगता कि मुझे यह पसंद आएगा कि अगर मैं GLRenderer::onDrawFrame विधि के अंदर अपना तर्क डालूं तो ऐसा कैसा लगेगा। जहां तक ​​मुझे पता है, यह विधि सिर्फ ड्रॉ करने के लिए है, और यदि मैं वहां तर्क डालता हूं तो मैं फ्रेम को धीमा कर सकता हूं। उल्लेख नहीं है कि यह मेरी समझ में पीओओ की अवधारणाओं को नुकसान पहुंचाता है।

मुझे लगता है कि धागे का उपयोग कर रास्ता हो सकता है, यह मैं कैसे योजना बना रहा था है:

मुख्य गतिविधि:

public void onCreate(Bundle savedInstanceState) { 
    //set fullscreen, etc 

    GLSurfaceView view = new GLSurfaceView(this); 
    //Configure view 

    GameManager game = new GameManager(); 
    game.start(context, view); 

    setContentView(view); 
} 

GameManager:

OpenGLRenderer renderer; 
Boolean running; 
public void start(Context context, GLSurfaceView view) { 
    this.renderer = new OpenGLRenderer(context); 
    view.setRenderer(this.renderer); 

    //create Texturelib, create sound system... 

    running = true; 
    //create a thread to run GameManager::update() 
} 

public void update(){ 
    while(running){ 
     //update game logic here 
     //put, edit and remove sprites from renderer list 
     //set running to false to quit game 
    } 
} 

और अंत में, OpenGLRenderer:

ListOrMap toDraw; 
public void onDrawFrame(GL10 gl) { 
    for(sprite i : toDraw) 
    { 
     i.draw(); 
    } 
} 

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

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

तो यहाँ मेरे सवालों हैं:

सबसे अच्छा तरीका है प्रतिपादन से मेरी खेल तर्क अलग जब OpenGLES का उपयोग कर रहा है कौन सा? मेरे एप्लिकेशन को थ्रेड करना? तर्क को एक अलग विधि में रखें और इसे ड्रॉ विधि से कॉल करें?

Answer 1

तो मुझे लगता है कि आप यहां दो तरीकों से जा सकते हैं।

1. onDrawFrame() से सभी अद्यतन करें: यह भरमार का उपयोग कर के समान है, और एंड्रॉयड इस समारोह जितनी बार संभव कॉल करेंगे। (setRenderMode(RENDERMODE_WHEN_DIRTY) के साथ इसे बंद करें।) इस फ़ंक्शन को अपने धागे (यूआई थ्रेड नहीं) पर बुलाया जाता है और इसका मतलब है कि आप यहां अपना तर्क अपडेट कहते हैं। आपका प्रारंभिक मुद्दा यह था कि यह थोड़ा गन्दा लगता है, और मैं सहमत हूं, लेकिन केवल इसलिए कि फ़ंक्शन का नाम onDrawFrame() है। अगर इसे onUpdateScene() कहा जाता है, तो तर्क अपडेट करना इस मॉडल को अच्छी तरह से फिट करेगा। लेकिन यह दुनिया में बदतर चीज नहीं है, इसे इस तरह से डिजाइन किया गया था, और लोग इसे करते हैं।

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

मैं # 1 की सिफारिश करता हूं। आपको वास्तव में # 2 की आवश्यकता नहीं है। यदि आप करते हैं, तो आप इसे बाद में जोड़ सकते हैं, लेकिन अधिकांश लोग केवल पहले विकल्प का उपयोग कर रहे हैं क्योंकि हार्डवेयर पर्याप्त तेज़ है इसलिए आपको इसके आसपास डिज़ाइन करने की आवश्यकता नहीं है।

Answer 2

मानक (और शायद सबसे अच्छा) दृष्टिकोण पीछा कर रहा है हो सके, आसान :) अपने डिजाइन रखें:

public void update(){ 
    while(running){ 
     updateAll(); 
     renderAll(); 
    } 
} 

मैं कुछ क्षणों पर ध्यान देना होगा:

आप
• update और render विधियों को क्रमशः कॉल करने की आवश्यकता है, update को दो बार
• पर कॉल करने से बचें, यदि आप एम पसंद करते हैं ultithreading (मैं नहीं), अपने तरीके डिजाइन इतना update डेटा लिखता है और render पढ़ता केवल
• ओपन यह अपने "सूत्र" है है कि ध्यान में रखना, इसलिए जब आप जीएल फ़ंक्शन को कॉल यह केवल ओपन करने के लिए कुछ आदेश (glFlush() छोड़कर भेजता है - यह सभी आदेशों को पूरा करता है)