🥠 🍷 🕺🏼 पहली बार कंकाल एनीमेशन 🚹 🐴 🤪

परिचय

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

मैंने क्या उपयोग किया?

MSVS 2013 व्यावसायिक मेरी प्राथमिक आईडीई है
Qt Creator - इसके साथ मैंने एक एनीमेशन एडिटिंग प्रोग्राम लिखा
Qt 5.1 - एनीमेशन संपादक के लिए GUI के रूप में
एसडीएल 2 - अंतिम कार्यक्रम में कमांड और ग्राफिक्स का इनपुट / आउटपुट (जहां एनीमेशन होना चाहिए)
OpenGL 2.1 - ग्राफिक्स प्रदर्शित करने के लिए
GLEW - ओपनजीएल एक्सटेंशन को जोड़ने के लिए
बूस्ट - टाइमर का उपयोग करने के लिए
Protobuf Google - एनीमेशन फ़ाइलों को सहेजने के लिए
सी ++ - पीएल जिस पर मैंने सब कुछ किया

कहाँ से शुरू करें?

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

शुरू करने के लिए, मैं अपना # प्रदर्शन दिखाऊंगा:

#define M_PI 3.1415926535 #define M_PI_2 M_PI/2 #define M_PI_3 M_PI/3 #define M_PI_4 M_PI/4 #define RAD1 M_PI/180.0f #define DEG1 180.0f/M_PI #define RAD2DEG(rad) rad*DEG1 #define DEG2RAD(deg) deg*RAD1 #define MAX_CHILDREN_COUNT 10 #define MAX_KEYFRAME_COUNT 20

और मैं आखिरकार ऐसी संरचनाओं में आया:

संयुक्त एक संयुक्त है

  typedef struct _Joint { //inheritanse _Joint* root; /* Pointer to root element. All elements have it. */ _Joint* parent; /* Pointer to parent */ //simple joints variables float x, y; /* Position */ float angle; /* Angle of rotate. In radians!!! */ uint8_t level; /* Level of hierarchy. Root have 0, next level +1 */ float dX, dY; /* Default Position */ float dAngle; /* Default Angle */ float aX, aY; /* Animation Position */ float aAngle; /* Animation Angle */ //children uint8_t childCount; /* Number of children */ _Joint* child[MAX_CHILDREN_COUNT]; /* Array of children */ //index uint16_t indexCount; /* Last number for index. Only Root have the var. */ uint16_t index; /* Unique index of joint */ } S_Joint;

dX, dY, dAngle - ये डिफ़ॉल्ट मान हैं। मैंने कोणों को रेडियंस में स्टोर करने का फैसला किया, 0 से 6.28 तक। और तब मुझे इससे बहुत समस्याएँ थीं। लेकिन उस पर और बाद में।

aX, aY, aAngle - ये एनीमेशन विकल्प हैं। वे इंगित करते हैं कि फ्रेम को पहले से ही प्रक्षेपित किया गया है। यही है, पिछले एनीमेशन उनमें दर्ज किए गए हैं। उदाहरण के लिए, एनीमेशन 900 एमएस ( TIME ), 450 एमएस ( अब ) के लिए रहता है, लेकिन एनीमेशन को हर मिलीसेकंड में अपडेट नहीं किया जा सकता है, इसलिए यदि आपके पास 400 एमएस पहले था, लेकिन अभी 450 है, एक्स को प्रक्षेपित करें और कल्पना करें कि पहले एक्स में 2 कुंजी हैं। = 50 ( KEY1 ), दूसरे 100 ( KEY2 ) में, तब X का अंतिम मान निम्न है:

_Joint.x += (KEY2 - KEY1) / TIME * NOW - _Joint.aX;

_Joint.aX = (KEY2 - KEY1) / TIME * NOW;

22,3 += (100-50) / 900 * 450 - 22,3

22.3 - यह एक्स पासा है, यह देखते हुए कि जब समय ( अब ) 0 था, तब एक्स भी शून्य था

कीडाटा और कीफ्रेम एनीमेशन के लिए संरचनाएं हैं

 typedef struct _KeyData { float x, y, angle; } S_KeyData; typedef struct _Keyframe { S_KeyData data; /* data of Joint */ uint16_t time; /* ~32 sec.(32768 ms) is maximum time for animation. Only Root have it */ uint16_t index; /* Index of joint, which we want interpolate */ _Keyframe* parent; uint8_t childCount; /* Number of children */ _Keyframe* child[MAX_CHILDREN_COUNT]; } S_Keyframe;

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

हमें 5 पुनरावृत्तियों के 10 चक्रों की आवश्यकता होगी, अर्थात् केवल 50 पुनरावृत्तियों। और अंत में पूरे पेड़ को अपडेट करते समय हमें 51 प्रक्षेप मिलते हैं। अन्यथा, यदि हम हड्डी की खोज का उपयोग करते हैं, तो पुनरावृत्तियों को अंतिम हड्डी जोड़ने के लिए 50 पुनरावृत्तियों की आवश्यकता होगी, 49 एक के लिए और इतने पर, पूरे पेड़ को अपडेट करने की तुलना में कुल मिलाकर। _Keyframe होने वाले इंडेक्स 0 , इस एनीमेशन के समय को स्टोर करता है, उसके सभी बच्चों का टाइम पैरामीटर 0 है।

एनीमेशन - कुंजी की एक सूची संग्रहीत करता है

  typedef struct _Animation { uint8_t keyNumber; uint8_t keyCount; S_Keyframe* key[MAX_KEYFRAME_COUNT]; } S_Animation;

KeyNumber शून्य पर डिफ़ॉल्ट खेलने के लिए एनीमेशन का सूचकांक है। कालानुक्रमिक क्रम में सभी ऐनिमेशन कुंजियाँ कुंजी सरणी में संग्रहीत की जाती हैं। कार्यान्वयन के सभी तरीके, संरचनाओं को हटाने और उनमें नई वस्तुओं को जोड़ने के लिए मैं छिपाऊंगा ताकि बहुत सारे कोड यहां ढेर न हों। लेकिन मैं एनीमेशन के लिए फ़ंक्शन दिखाऊंगा।

 bool doAnimation(S_Joint *root, S_Animation *anim, uint16_t time) { if (!root) return false; if (!anim) return false; bool timeOut = true; for (int i = 0; i < anim->keyCount; i++) { if (time < anim->key[i]->time) //search keyframes for interpolation { //  1200,  2400, 2400-1200=1200 uint16_t mtime = anim->key[i]->time - anim->key[i - 1]->time; //nowTime is 1560, mtime = 1200(ERROR), 1560 - 1200(last key)=360(realtime) uint16_t nowTime = time - anim->key[i - 1]->time; if (i != anim->keyNumber) //    keyNumber,        { setDefaultAnimTree(root); //set to 0.0 animation changes(aX,yX,aAngle) } anim->keyNumber = i; //   doInterpolate(root, anim->key[i - 1], anim->key[i], mtime, nowTime); timeOut = false; break; } } if (timeOut == true) { setDefaultTree(root); //          } return timeOut; }

जब फ़ंक्शन सही हो जाता है, तो टाइमर शून्य पर रीसेट हो जाता है। (बूस्ट :: टाइमर)

और अंतिम समारोह:

 void doInterpolate(S_Joint* root, S_Keyframe* key1, S_Keyframe* key2, uint16_t time, uint16_t nowTime) { if (root->index != key2->index) return; float x = (key2->data.x - key1->data.x) / time * nowTime; //        float y = (key2->data.y - key1->data.y) / time * nowTime; float angle = (key2->data.angle - key1->data.angle) / time * nowTime; root->x += x - root->aX; //root->aX -        ,        root->y += y - root->aY; root->angle += angle - root->aAngle; root->aX = x; //     ,     x,y,angle root->aY = y; root->aAngle = angle; //     for (int i = 0; i < root->childCount; i++) { doInterpolate(root->child[i], key1->child[i], key2->child[i], time, nowTime); } }

यहाँ इस तरह का कंकाल एनीमेशन है और यह बहुत अच्छी तरह से काम करता है। क्यूटी में कार्यक्रम बनाने के चरण में समस्याओं का एक गुच्छा उत्पन्न हुआ, और बहुत पहले माउस के साथ हड्डियों का आंदोलन है, और वास्तव में हड्डियों का आंदोलन है। 6.28 के सर्कल में हड्डी की रोटेशन की लंबाई, यानी 2 * पाई या 360 डिग्री। लेकिन परिणामी आंदोलन केवल एक दिशा में होता है। यदि हम प्राप्त करते हैं, तो गणना 4.47 में कहते हैं, लेकिन विपरीत दिशा में आगे बढ़ना चाहते हैं, सिद्धांत रूप में हम ऐसा कर सकते हैं:

4,47-6.28=-1,81

यह विपरीत दिशा में आगे बढ़ने लगता है। लेकिन यह बहुत सुविधाजनक नहीं है। मैंने रोटेशन लक्ष्य के लिए इष्टतम पथ की खोज करने की भी कोशिश की। यदि हम कल्पना करते हैं कि हमारी स्थिति 1.57 (ए) है, तो हमारा लक्ष्य 5.57 (बी) है, तब:

 negAngle = BA; posAngle = (B-6.28)-A; if(fabs(posAngle) > fabs(negAngle)) { /* */ }

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

पहली बार कंकाल एनीमेशन