मेरे भौतिकी इंजन में गति और अद्यतन समस्याओं का क्रम


22

यहां छवि विवरण दर्ज करें

यह सवाल टकराव का पता लगाने और समाधान के बारे में मेरे पिछले एक से एक "अनुवर्ती" सवाल है, जिसे आप यहां पा सकते हैं ।


यदि आप पिछले प्रश्न को नहीं पढ़ना चाहते हैं, तो मेरा भौतिकी इंजन कैसे काम करता है, इसका संक्षिप्त विवरण यहाँ है:

प्रत्येक भौतिक इकाई को SSSPBody नामक एक वर्ग में संग्रहीत किया जाता है।

केवल AABB का समर्थन किया जाता है।

हर SSSPBody SSSPWorld नामक एक वर्ग में संग्रहीत है, जो हर शरीर को अपडेट करता है और गुरुत्वाकर्षण को संभालता है।

हर फ्रेम, SSSPWorld हर बॉडी को अपडेट करता है।

प्रत्येक अद्यतन निकाय एक स्थानिक हैश में आस-पास के शवों की तलाश करता है, जांच करता है कि क्या उन्हें उनके साथ टकराव का पता लगाने की आवश्यकता है। यदि हाँ, तो वे "टकराव" की घटना को रोकते हैं और जाँचते हैं कि क्या उनके साथ टकराव को हल करने की आवश्यकता है। यदि हाँ, वे पैठ वेक्टर और दिशात्मक ओवरलैप की गणना करते हैं, तो पैठ को हल करने के लिए अपनी स्थिति को बदल दें।

जब कोई शरीर दूसरे से टकराता है, तो वह अपने वेग को दूसरे के पास स्थानांतरित कर देता है, बस शरीर के वेग को अपने आप ही सेट कर देता है।

एक शरीर का वेग 0 पर सेट होता है जब उसने अंतिम फ्रेम से स्थिति नहीं बदली है। यदि यह एक गतिशील पिंड के साथ भी टकराता है (जैसे कि एक लिफ्ट या एक गतिशील प्लेटफ़ॉर्म) तो यह लिफ्ट के संचलन अंतर की गणना करता है कि यह देखने के लिए कि क्या पिंड अपनी अंतिम स्थिति से स्थानांतरित नहीं हुआ है।

इसके अलावा, एक निकाय एक "कुचल" घटना को आमंत्रित करता है जब इसके सभी एएबीबी कोनों को एक फ्रेम में कुछ ओवरलैप किया जाता है।

यह मेरे खेल का पूर्ण स्रोत कोड है। यह तीन परियोजनाओं में विभाजित है। SFMLStart इनपुट, ड्राइंग और संस्थाओं के अद्यतन से निपटने के लिए एक सरल पुस्तकालय है। SFMLStartPhysics सबसे महत्वपूर्ण है, जहां SSSPBody और SSSPWorld कक्षाएं हैं। PlatformerPhysicsTest गेम प्रोजेक्ट है, जिसमें सभी गेम लॉजिक हैं।

और यह SSSPBody वर्ग में "अपडेट" विधि है, टिप्पणी और सरलीकृत। आप केवल इस पर एक नज़र डाल सकते हैं यदि आपको संपूर्ण SFMLStartSimplePhysics प्रोजेक्ट को देखने का मन नहीं है। (और यदि आप करते हैं, तब भी आपको टिप्पणी करने के बाद भी इस पर एक नज़र रखना चाहिए।)


.Gif दो समस्याओं को दिखाता है।

  1. यदि निकायों को एक अलग क्रम में रखा जाता है, तो अलग परिणाम होते हैं। बाईं ओर के बक्से दाईं ओर के बक्से के समान हैं, केवल उलटा क्रम (संपादक में) में रखा गया है।
  2. दोनों क्रेट्स को स्क्रीन के शीर्ष की ओर ले जाना चाहिए। बाईं ओर की स्थिति में, कोई भी टोकरा प्रवृत्त नहीं होता है। दाईं ओर, उनमें से केवल एक है। दोनों ही स्थितियाँ अनायास ही हैं।

पहली समस्या: अपडेट का क्रम

यह समझने में काफी सरल है। बाईं ओर की स्थिति में, सबसे ऊपरी टोकरा दूसरे से पहले अद्यतन किया जाता है। भले ही तल पर टोकरा दूसरे के लिए "वेग" स्थानांतरित करता है, इसे स्थानांतरित करने के लिए अगले फ्रेम की प्रतीक्षा करने की आवश्यकता है। चूंकि यह नहीं चला, इसलिए नीचे के टोकरे का वेग 0 पर सेट है।

मुझे यह पता नहीं है कि इसे कैसे ठीक किया जाए। मैं अपडेट सूची में "सॉर्टिंग" पर निर्भर नहीं होने के समाधान को प्राथमिकता दूंगा, क्योंकि मुझे लगता है कि मैं पूरे भौतिकी इंजन डिजाइन में कुछ गलत कर रहा हूं।

प्रमुख भौतिकी इंजन (Box2D, बुलेट, चिपमंक) अपडेट ऑर्डर को कैसे संभालते हैं?


दूसरी समस्या: केवल एक टोकरा छत की ओर प्रवृत्त होता है

मुझे अभी तक समझ नहीं आया कि ऐसा क्यों होता है। "स्प्रिंग" इकाई क्या करती है, शरीर के वेग को -4000 पर सेट कर देती है और इसे स्प्रिंग के ऊपर स्थित कर देती है। भले ही मैं पुन: स्थिति कोड को अक्षम कर दूं, फिर भी समस्या होती है।

मेरा विचार यह है कि जब नीचे का टोकरा शीर्ष टोकरा से टकराता है, तो इसका वेग 0. पर सेट होता है, मुझे यकीन नहीं है कि ऐसा क्यों होता है।


पहली समस्या को छोड़ देने वाले किसी व्यक्ति की तरह दिखने की संभावना के बावजूद, मैंने पूरे प्रोजेक्ट स्रोत कोड को ऊपर पोस्ट किया। मेरे पास इसे साबित करने के लिए कुछ भी नहीं है, लेकिन मेरा विश्वास करो, मैंने इसे ठीक करने की बहुत कोशिश की, लेकिन मुझे इसका कोई हल नहीं मिला और मेरे पास भौतिकी और टकरावों का कोई पिछला अनुभव नहीं है। मैं इन दोनों समस्याओं को एक सप्ताह से अधिक समय से हल करने की कोशिश कर रहा हूं और अब मैं हताश हूं।

मुझे नहीं लगता कि मैं खेल से बाहर कई विशेषताओं को हटाए बिना अपने आप पर एक समाधान पा सकता हूं (उदाहरण के लिए स्थानांतरण और स्प्रिंग्स, उदाहरण के लिए)।

इस प्रश्न को पढ़ने में बिताए गए समय के लिए बहुत बहुत धन्यवाद, और इससे भी अधिक धन्यवाद यदि आप भी समाधान या सुझाव के साथ आने की कोशिश करते हैं।


जब भी आप बक्से को ढेर करते हैं तो क्या आप उनकी भौतिकी को जोड़ सकते हैं ताकि उन्हें एक ही वस्तु माना जाए?
सिस्कोपिपोन

जवाबों:


12

दरअसल, सामान्य आवेग भौतिकी इंजनों के लिए अद्यतन समस्याओं का क्रम काफी सामान्य है, आप केवल बल लागू करने में देरी नहीं कर सकते हैं जैसा कि विजिल का सुझाव है, जब आप एक वस्तु को 2 अन्य के साथ टकराते हैं तो आप ऊर्जा संरक्षण को समाप्त कर देंगे। आमतौर पर वे हालांकि ऐसा कुछ बनाने का प्रबंधन करते हैं जो बहुत वास्तविक लगता है, भले ही अद्यतन के एक अलग क्रम ने काफी अलग परिणाम दिया हो।

किसी भी मामले में, आपके उद्देश्य के लिए एक आवेग प्रणाली में पर्याप्त हिचकी है जो मैं आपको एक बड़े पैमाने पर वसंत मॉडल बनाने के बजाय सुझाव देना चाहूंगा।

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

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

आप टकराव की लंबवत दिशा में एक वस्तु को ब्रेक करके एक घर्षण प्रभाव भी बना सकते हैं, ब्रेकिंग की मात्रा ओवरलैप की मात्रा के बराबर होनी चाहिए।

आप सभी वस्तुओं को समान द्रव्यमान देकर आसानी से द्रव्यमान की अवधारणा के आसपास प्राप्त कर सकते हैं, और अचल वस्तुएं अनंत द्रव्यमान की तरह काम करेंगी यदि आप बस उन्हें तेज करने की उपेक्षा करते हैं।

कुछ छद्म कोड, बस के मामले में ऊपर पर्याप्त स्पष्ट नहीं था:

//Presuming that you have done collision checks between two objects and now have  
//numbers for how much they overlap in each direction.
overlapX
overlapY
if(overlapX<overlapY){ //Do collision in direction X
    if(obj1.X>obj2.X){
        swap(obj1,obj2)
    }
    //Spring effect:
    obj1.addXvelocity-=overlapX*0.1 //Constant, the lower this is set the softer the  
                                    //collision will be.
    obj2.addXvelocity+=overlapX*0.1
    //Dampener effect:
    velocityDifference=obj2.Xvelocity-obj1.Xvelocity
    //velocityDifference=min(velocityDifference,0) //Uncomment to only dampen when  
                                                   //objects move towards each other.
    obj1.addXvelocity+=velocityDifference*0.1 //Constant, higher for more dampening.
    obj2.addXvelocity-=velocityDifference*0.1
    //Friction effect:
    if(obj1.Yvelocity>obj2.Yvelocity){
        swap(obj1,obj2)
    }
    friction=overlapX*0.01
    if(2*friction>obj2.Yvelocity-obj1.Yvelocity){
        obj1.addYvelocity+=(obj2.Yvelocity-obj1.Yvelocity)/2
        obj2.addYvelocity-=(obj2.Yvelocity-obj1.Yvelocity)/2
    }
    else{
        obj1.addYvelocity+=friction
        obj2.addYvelocity-=friction
    }
}
else{ //Do collision in direction Y

}

AddXvelocity और addYvelocity गुणों की बात यह है कि ये सभी टकराव से निपटने के बाद उनकी वस्तु के वेग में जुड़ जाते हैं।

संपादित करें:
आप निम्नलिखित क्रम में सामान कर सकते हैं, जहां प्रत्येक बुलेट को अगले प्रदर्शन से पहले सभी तत्वों पर किया जाना चाहिए:

  • टकराव का पता लगाएं, उनका पता चलते ही उनका समाधान किया जा सकता है।
  • AddVelocity मानों को वेग मानों में जोड़ें, गुरुत्वाकर्षण Yvelocity जोड़ें, addVelocity मानों को 0 पर रीसेट करें, ऑब्जेक्ट्स को उनके वेग के अनुसार स्थानांतरित करें।
  • दृश्य रेंडर करें।

इसके अलावा, मुझे एहसास है कि गुरुत्वाकर्षण के प्रभाव के तहत मेरी प्रारंभिक पोस्ट में निम्नलिखित पूरी तरह से स्पष्ट नहीं हो सकता है, जब एक दूसरे के ऊपर आराम कर रहे हैं, तो यह ओवरलैपिंग से बचने के लिए उनके टकराव बॉक्स उनके चित्रमय प्रतिनिधित्व से थोड़ा अधिक होना चाहिए। नेत्रहीन। यदि उच्चतर अद्यतन दर पर भौतिकी को चलाया जाता है तो यह समस्या कम होगी। मेरा सुझाव है कि आप CPU समय और भौतिकी सटीकता के बीच एक उचित समझौता करने के लिए 120Hz पर चलने का प्रयास करें।

Edit2:
बहुत बुनियादी भौतिकी इंजन प्रवाह:

  • टकराव और गुरुत्वाकर्षण बल / त्वरण का उत्पादन करते हैं। acceleration = [Complicated formulas]
  • बल / त्वरण वेग में जोड़े जाते हैं। velocity += acceleration
  • वेग को स्थिति में जोड़ा जाता है। position += velocity

अच्छा लगता है, प्लेटफॉर्मर्स के लिए बड़े पैमाने पर वसंत के बारे में कभी नहीं सोचा। कुछ प्रबुद्ध करने के लिए अंगूठे :)
पर्याप्त

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

मुझे पूरी तरह से यकीन नहीं है कि आपके पहले प्रश्न की व्याख्या कैसे करें। टकराव संकल्प वेग को बदल देगा, और इस प्रकार केवल अप्रत्यक्ष रूप से प्रभाव स्थिति।
आआआआआआआआआआआआआ आआआआआआआआ आआआआआआ

तथ्य यह है कि मैं संस्थाओं को मैन्युअल रूप से उनके वेग को एक निश्चित मूल्य पर सेट करके स्थानांतरित करता हूं। ओवरलैप्स को हल करने के लिए, मैं उनकी स्थिति से ओवरलैप की दूरी को हटा देता हूं। यदि मैं आपकी विधि का उपयोग करता हूं, तो क्या मुझे बलों या कुछ और का उपयोग करके संस्थाओं को स्थानांतरित करना होगा? मैंने पहले कभी ऐसा नहीं किया।
विटोरियो रोमियो

तकनीकी रूप से, हाँ, आपको बलों का उपयोग करना होगा, मेरे कोड ऑफ़ कोड में हालांकि यह सभी वस्तुओं के साथ थोड़ा सरल किया गया है जिनका वजन 1 है, और इसलिए बल त्वरण के बराबर है।
आआआआआआआआआआआआआआ आआआआआ

14

ठीक है, आप स्पष्ट रूप से कोई ऐसा व्यक्ति नहीं हैं जो आसानी से हार मान लेता है, आप लोहे के असली आदमी हैं, मैंने अपने हाथ हवा में बहुत पहले फेंक दिए हैं, क्योंकि यह परियोजना एक kelp वन के लिए एक मजबूत समानता रखती है :)

सबसे पहले, स्थान और वेग सभी जगह पर सेट होते हैं, भौतिकी उप-प्रणाली के दृष्टिकोण से यह एक आपदा के लिए एक नुस्खा है। इसके अलावा, विभिन्न उप-प्रणालियों द्वारा अभिन्न चीजों को बदलते समय, "ChangeVelocityByPhysicsEngine", "ChangeVelocityBySpring", "LimitVelocity", "TransferVelocity" या ऐसा कुछ जैसे एक निजी तरीके बनाएं। यह तर्क के एक विशिष्ट भाग द्वारा किए गए परिवर्तनों की जाँच करने की क्षमता को जोड़ देगा और इन वेग परिवर्तनों को एक अतिरिक्त अर्थ प्रदान करेगा। इस तरह डिबगिंग आसान हो जाएगी।

पहली समस्या।

सवाल पर ही। अब आप सिर्फ पोजीशन और वेलोसिटी फिक्स लागू कर रहे हैं, जैसा कि वे जाते हैं "उपस्थिति और खेल तर्क के क्रम में"। प्रत्येक जटिल चीज़ के भौतिकी को सावधानीपूर्वक हार्ड-कोडिंग के बिना जटिल इंटरैक्शन के लिए काम नहीं करेगा। एक अलग भौतिकी इंजन की जरूरत नहीं है।

हैक्स के बिना जटिल इंटरैक्शन करने के लिए, आपको उन स्थितियों के आधार पर टकराव का पता लगाने के बीच एक अतिरिक्त कदम जोड़ने की आवश्यकता है जो प्रारंभिक वेगों द्वारा बदल दिए गए थे और "बाद के वेग" के आधार पर पदों के अंतिम परिवर्तन। मुझे लगता है कि यह इस तरह होगा:

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

अतिरिक्त चीजें पॉप अप हो सकती हैं, जैसे झटके से निपटना, एफपीएस छोटा होने पर स्टैक करने से इनकार करना, या इस तरह की अन्य चीजें, तैयार होना :)

दूसरी समस्या

उन दोनों "डेडवेट" बक्से के ऊर्ध्वाधर वेग कभी भी शून्य से नहीं बदलते हैं। अजीब बात है, PhysSpring के अपडेट लूप में आप वेग प्रदान करते हैं, लेकिन PhysCrate के अपडेट लूप में यह पहले से ही शून्य है। यह संभव है कि एक रेखा मिल जाए जहां वेग गलत हो, लेकिन मैंने "रीप व्हाट यू सीव" स्थिति के बाद से यहां डिबगिंग बंद कर दी। यह कोडिंग बंद करने और डिबगिंग कठिन होने पर सब कुछ पुनर्विचार करना शुरू करने का समय है। लेकिन अगर यह उस बिंदु पर आता है जहां कोड के लेखक के लिए यह समझना असंभव है कि कोड में क्या हो रहा है, तो आपका कोड आधार पहले ही मर चुका है, जब तक आप इसे साकार किए बिना :)

तीसरी समस्या

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


मुझे पसंद है कि "केल्प वन" की तुलना।
डेन

वास्तव में, मुझे इस तरह के शब्दों का उपयोग करने में थोड़ी शर्म आती है, लेकिन मुझे लगा कि अगर यह एक रीफैक्टरिंग या दो में परिणत होता है, तो यह उचित होगा।
11

टी में केवल एक ही परीक्षण के साथ हमेशा एक संभावना नहीं होगी कि ऐसा होता है? मुझे लगता है कि आपको टी पर वेग को एकीकृत करने की आवश्यकता होगी और फिर किसी भी वेग को 0 पर सेट करने से पहले टी + 1 में टकराव की जाँच करें ?
जोनाथन कॉनवेल

हाँ, हम आगे की स्थिति का पता लगाने के बाद टी-टीटी से आगे की अवस्था को रन-कुट्टा या कुछ और का उपयोग करके एकीकृत कर रहे हैं।
पर्याप्त

"शरीर पर काम करने वाली सभी ताकतों का उपयोग करके वेग को एकीकृत करें" "अपने भौतिकी इंजन के लिए वेग की गणना छोड़ दें" - मैं समझता हूं कि आप क्या कहना चाह रहे हैं, लेकिन मुझे ऐसा करने का कोई सुराग नहीं है। क्या कोई उदाहरण / लेख है जो आप मुझे दिखा सकते हैं?
विटोरियो रोमियो

7

जब कोई शरीर दूसरे से टकराता है, तो वह अपने वेग को दूसरे के पास स्थानांतरित कर देता है, बस शरीर के वेग को अपने आप ही सेट कर देता है।

आपकी समस्या यह है कि ये गति के बारे में मौलिक रूप से गलत धारणाएं हैं, इसलिए जो आप प्राप्त कर रहे हैं वह गति जैसा नहीं है क्योंकि आप इससे परिचित हैं।

जब एक शरीर दूसरे से टकराता है, तो संवेग का संरक्षण होता है। इसे "ए हिट बी" बनाम "बी हिट ए" के रूप में सोचना एक अकर्मक स्थिति में एक सकर्मक क्रिया को लागू करना है। ए और बी टकराते हैं; परिणामी गति प्रारंभिक गति के बराबर होनी चाहिए। यही है, अगर ए और बी समान द्रव्यमान हैं, तो वे अब अपने मूल वेग के साथ यात्रा कर रहे हैं।

आपको कुछ टकराव ढलान और पुनरावृत्त सॉल्वर की भी आवश्यकता होगी, या आप स्थिरता के मुद्दों में भाग लेंगे। आपको शायद एरिन कट्टो की जीडीसी प्रस्तुतियों में से कुछ के माध्यम से पढ़ना चाहिए।


2
वे केवल मूल वेग का अर्थ प्राप्त करेंगे यदि टकराव पूरी तरह से अकुशल है, जैसे कि ए और बी आटा के टुकड़े हैं।
मिकेल

"बस शरीर के वेग को अपने आप निर्धारित करके"। यह इस तरह से बयान करता है कि यह क्यों काम नहीं कर रहा है को रोशन करता है। सामान्य तौर पर मैंने हमेशा पाया है कि अनुभवहीन लोग सम्मिलित सिद्धांतों को समझे बिना भौतिकी प्रणाली लिखते हैं। आप कभी 'बस वेग सेट', या 'बस ...' नहीं करते। एक शरीर के गुणों का हर संशोधन डायनेमिक्स के नियमों का प्रत्यक्ष आवेदन होना चाहिए; संवेग, ऊर्जा आदि के संरक्षण सहित, हाँ अस्थिरताओं की भरपाई करने के लिए हमेशा ठगना कारक होगा, लेकिन किसी भी बिंदु पर आप केवल जादुई रूप से शरीर के वेग को नहीं बदल सकते।
MrCranky

जब पहली बार में इंजन को चलाने की कोशिश की जाती है, तो यह आसान नहीं होता है कि समस्या को हल करने के लिए यह कम जटिल हो।
पैट्रिक ह्यूजेस

4

मुझे लगता है कि आपने वास्तव में अच्छा प्रयास किया है, लेकिन ऐसा लगता है कि मूलभूत समस्याएं हैं कि कोड कैसे संरचित है। जैसा कि अन्य ने सुझाव दिया है, यह परिचालन को विवेकशील भागों में अलग करने में मदद कर सकता है, जैसे:

  1. व्यापक चरण : सभी वस्तुओं के माध्यम से लूप - एक त्वरित परीक्षण (जैसे, एएबीबी) यह निर्धारित करने के लिए कि कौन सी वस्तु टकरा सकती है - जो नहीं हैं उन्हें त्यागें।
  2. संकीर्ण चरण : सभी टकराने वाली वस्तुओं के माध्यम से लूप - टकराव के लिए एक पैठ वेक्टर की गणना करें (जैसे, सैट का उपयोग करके)।
  3. टक्कर की प्रतिक्रिया : टक्कर वैक्टर की सूची के माध्यम से लूप - द्रव्यमान के आधार पर एक बल वेक्टर की गणना करें, फिर एक त्वरण वेक्टर की गणना करने के लिए इसका उपयोग करें।
  4. एकीकरण : सभी त्वरण वैक्टर के माध्यम से लूप और एकीकृत स्थिति (और यदि आवश्यक हो तो रोटेशन)।
  5. प्रतिपादन : सभी गणना की गई स्थितियों के माध्यम से लूप करें और प्रत्येक ऑब्जेक्ट को रेंडर करें।

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

उस ने कहा, इन भागों में से प्रत्येक अपने आप में एक विज्ञान है, और इष्टतम समाधान खोजने की कोशिश कर रहे समय का एक बड़ा हिस्सा कब्जा कर सकते हैं। सबसे अधिक इस्तेमाल किए जाने वाले कुछ एल्गोरिदम के साथ शुरू करना बेहतर हो सकता है:

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

न्यूटन के गति के नियमों के साथ एक अच्छी (और स्पष्ट) जगह शुरू होती है ।


उत्तर के लिए धन्यवाद। हालांकि, मैं निकायों के बीच वेग को कैसे स्थानांतरित करूं? क्या यह एकीकरण के चरण के दौरान होता है?
विटोरियो रोमियो

एक अर्थ में, हाँ। वेलोसिटी ट्रांसफर की शुरुआत टक्कर प्रतिक्रिया चरण से होती है। वह यह है कि जब आप निकायों पर कार्रवाई करने वाले बलों की गणना करते हैं। फोर्स सूत्र त्वरण = बल / द्रव्यमान का उपयोग करके त्वरण में अनुवाद करता है। वेग की गणना के लिए एकीकरण चरण में त्वरण का उपयोग किया जाता है, जो तब स्थिति की गणना करने के लिए उपयोग किया जाता है। एकीकरण चरण की सटीकता निर्धारित करती है कि समय के साथ वेग (और बाद की स्थिति) कितनी सही है।
ल्यूक वान
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.