👩🏿‍🎤 🕴🏾 ✅ यूनिटी 3 डी में ध्वनि और संगीत आधारित पर्यावरण पीढ़ी। भाग 2. संगीत से 2 डी ट्रैक बनाना 🕍 🍇 🔶

अमूर्त

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

परिचय

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

आज का हमारा रोड मैप यहां है:

विचार करें कि विवेक क्या है।
पता करें कि हम ऑडियो क्लिप यूनिटी से कौन सा डेटा प्राप्त कर सकते हैं
समझें कि हम इस डेटा के साथ कैसे काम कर सकते हैं।
पता करें कि हम इस डेटा से क्या उत्पन्न कर सकते हैं।
जानें कि इस खेल को कैसे बनाया जाए (अच्छी तरह से, या खेल के समान कुछ)

तो चलिए!

एनालॉग सिंहल का विवेक

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

अक्षर T नमूना अवधि को इंगित करता है। कम अवधि, सिग्नल रूपांतरण जितना सटीक होगा। लेकिन अक्सर वे उलटा के बारे में बात करते हैं: नमूना दर (यह तर्कसंगत है कि यह एफ = 1 / टी है)। टेलीफोन सिंगनल के लिए 8,000 हर्ट्ज पर्याप्त है, और, उदाहरण के लिए, डीवीडी-ऑडियो प्रारूप के लिए विकल्पों में से एक को 192,000 हर्ट्ज की नमूना आवृत्ति की आवश्यकता होती है। डिजिटल रिकॉर्डिंग (खेल संपादकों, संगीत संपादकों में) का मानक 44 100 हर्ट्ज है - यह सीडी ऑडियो की आवृत्ति है।

आयाम के संख्यात्मक मान तथाकथित नमूनों में संग्रहीत किए जाते हैं और यह उनके साथ है कि हम काम करेंगे। नमूने का मूल्य फ्लोट है और यह -1 से 1 तक हो सकता है। सरलीकृत, यह इस तरह दिखता है।

ध्वनि तरंग प्रतिपादन (स्थिर)

बुनियादी जानकारी

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

कल्पना करें कि हमारे पास पहले से ही एक ऑडियो स्रोत और एक स्क्रिप्ट है जिसमें हम काम करते हैं। आइए देखें कि एकता हमें क्या दे सकती है।

//  AudioSource    AudioSource myAudio = gameObject.GetComponent<AudioSource>(); //     .     44100. int freq = myAudio.clip.frequency;

रिपोर्ट की संख्या का चयन करें

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

यदि आप पेशेवर ऑडियो सॉफ़्टवेयर नहीं बनाते हैं, तो आपको ऐसी सटीकता की आवश्यकता नहीं है। एक सामान्य ऑडियो चित्र के लिए, हम सभी नमूनों को बड़ी अवधि में तोड़ सकते हैं और उदाहरण के लिए, प्रत्येक 100 नमूनों का औसत ले सकते हैं। तब हमारी तरंग का एक अलग रूप होगा:

बेशक, यह पूरी तरह से सही नहीं है, क्योंकि आप वॉल्यूम चोटियों को छोड़ सकते हैं जिनकी आपको आवश्यकता हो सकती है, इसलिए आप औसत मूल्य नहीं, बल्कि इस सेगमेंट से अधिकतम की कोशिश कर सकते हैं। यह थोड़ा अलग चित्र देगा, लेकिन आपकी चोटियाँ गायब नहीं होंगी।

ऑडियो प्राप्त करने की तैयारी कर रहा है

चलो गुणवत्ता के रूप में हमारे नमूने की सटीकता को परिभाषित करते हैं, और अंतिम संख्या के नमूने के रूप में रिपोर्ट करते हैं।

 int quality = 100; int sampleCount = 0; sampleCount = freq / quality;

सभी नंबरों की गणना का एक उदाहरण नीचे होगा।

अगला, हमें स्वयं नमूने प्राप्त करने की आवश्यकता है। यह GetData पद्धति का उपयोग करके एक ऑडियो क्लिप से किया जा सकता है।

 public bool GetData(float[] data, int offsetSamples);

यह विधि एक सरणी लेती है जिसमें यह नमूने लिखता है। ऑफसेटसमेन्स - पैरामीटर जो डेटा सरणी को पढ़ने के शुरुआती बिंदु के लिए जिम्मेदार है। यदि आप शुरुआत से सरणी पढ़ते हैं, तो शून्य होना चाहिए।

नमूने रिकॉर्ड करने के लिए, हमें उनके लिए एक सरणी तैयार करने की आवश्यकता है। उदाहरण के लिए, इस तरह:

 float[] samples; float[] waveFormArray; //      samples = new float[myAudio.clip.samples * myAudio.clip.channels];

हमने चैनलों की संख्या से लंबाई क्यों बढ़ाई? अब मैं बताऊंगा ...

एकता ऑडियो चैनल की जानकारी

बहुत से लोग जानते हैं कि ध्वनि में हम आमतौर पर दो चैनलों का उपयोग करते हैं: बाएं और दाएं। किसी को पता है कि 2.1 सिस्टम हैं, साथ ही 5.1, 7.1 है जिसमें ध्वनि स्रोत सभी तरफ से घिरे हैं। चैनलों की थीम विकी पर अच्छी तरह से वर्णित है। यह एकता में कैसे काम करता है?

फ़ाइल डाउनलोड करते समय, क्लिप खोलते समय, आप निम्न छवि पा सकते हैं:

बस यहां दिखाया गया है कि हमारे पास दो चैनल हैं, और आप यह भी देख सकते हैं कि वे एक दूसरे से अलग हैं। एकता इन चैनलों के नमूने एक के बाद एक दर्ज करती हैं। यह इस तस्वीर को बदल देता है:
$[L_1, R_1, L_2, R_2, L_3, R_3, L_4, R_4, L_5, R_5, L_6, R_6, L_7, R_7, L_8, R_8 ...]$

इसीलिए हमें सरणी में केवल नमूनों की संख्या की तुलना में दोगुना स्थान चाहिए।

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

ऑडियो डेटा प्राप्त करें

यहाँ हम क्या मिलता है:

 private int quality = 100; private int sampleCount = 0; private float[] waveFormArray; private float[] samples; private AudioSource myAudio; void Start() { myAudio = gameObject.GetComponent<AudioSource>(); int freq = myAudio.clip.frequency; sampleCount = freq / quality; samples = new float[myAudio.clip.samples * myAudio.clip.channels]; myAudio.clip.GetData(samples,0); //  ,    .       waveFormArray = new float[(samples.Length / sampleCount)]; //             for (int i = 0; i < waveFormArray.Length; i++) { waveFormArray[i] = 0; for (int j = 0; j < sampleCount; j++) { //Abs     ""    . .  waveFormArray[i] += Mathf.Abs(samples[(i * sampleCount) + j]); } waveFormArray[i] /= sampleCount; } }

कुल मिलाकर, यदि ट्रैक 10 सेकंड जाता है और यह दो-चैनल है, तो हमें निम्नलिखित मिलेंगे:

क्लिप में नमूने की संख्या (myAudio.clip.sample) = 44100 * 10 = 441000
दो चैनलों के लिए नमूने सरणी लंबी है (नमूने। गति) = 441000 * 2 = 882000
रिपोर्टों की संख्या (नमूना) = 44100/100 = 441
अंतिम सरणी की लंबाई = नमूने। गति / नमूनाकाउंट = 2000

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

ऑडियो जानकारी का प्रतिपादन

डीबग टूल का उपयोग करके एक साधारण ऑडियो ट्रैक बनाएं

जैसा कि बहुत से लोग जानते हैं, एकता में डिबग जानकारी के सभी प्रकार को प्रदर्शित करने के लिए सुविधाजनक साधन हैं। इन उपकरणों पर आधारित एक बुद्धिमान डेवलपर, उदाहरण के लिए, संपादक के लिए बहुत शक्तिशाली एक्सटेंशन बना सकता है। हमारा मामला डिबग विधियों का एक बहुत ही atypical उपयोग दर्शाता है।

ड्राइंग के लिए, हमें एक पंक्ति की आवश्यकता है। हम इसे एक वेक्टर की मदद से कर सकते हैं जो हमारे सरणी के मूल्यों से बनाया जाएगा। कृपया ध्यान दें, एक सुंदर दर्पण ऑडियो रूप बनाने के लिए, हमें अपने दृश्य के दो हिस्सों को "गोंद" करना होगा।

 for (int i = 0; i < waveFormArray.Length - 1; i++) { //      Vector3 upLine = new Vector3(i * .01f, waveFormArray[i] * 10, 0); //      Vector3 downLine = new Vector3(i * .01f, -waveFormArray[i] * 10, 0); }

अगला, बस हमारे वैक्टर को आकर्षित करने के लिए Debug.DrawLine का उपयोग करें। कोई भी रंग चुन सकते हैं। इन सभी तरीकों को अपडेट में बुलाया जाना चाहिए, इसलिए हम जानकारी को हर फ्रेम में अपडेट करेंगे।

 Debug.DrawLine(upLine, downLine, Color.green);

यदि आप चाहते हैं, तो आप एक "स्लाइडर" जोड़ सकते हैं जो ट्रैक की वर्तमान स्थिति को खेला जाएगा। यह जानकारी "AudioSource.timeSamples" फ़ील्ड से प्राप्त की जा सकती है।

 private float debugLineWidth = 5; // ""  .       int currentPosition = (myAudio.timeSamples / quality) * 2; Vector3 drawVector = new Vector3(currentPosition * 0.01f, 0, 0); Debug.DrawLine(drawVector - Vector3.up * debugLineWidth, drawVector + Vector3.up * debugLineWidth, Color.white);

कुल, यहाँ हमारी स्क्रिप्ट है:

 using UnityEngine; public class WaveFormDebug : MonoBehaviour { private readonly int quality = 100; private int sampleCount = 0; private int freq; private readonly float debugLineWidth = 5; private float[] waveFormArray; private float[] samples; private AudioSource myAudio; private void Start() { myAudio = gameObject.GetComponent<AudioSource>(); //  freq = myAudio.clip.frequency; sampleCount = freq / quality; //  samples = new float[myAudio.clip.samples * myAudio.clip.channels]; myAudio.clip.GetData(samples, 0); //       waveFormArray = new float[(samples.Length / sampleCount)]; for (int i = 0; i < waveFormArray.Length; i++) { waveFormArray[i] = 0; for (int j = 0; j < sampleCount; j++) { waveFormArray[i] += Mathf.Abs(samples[(i * sampleCount) + j]); } waveFormArray[i] /= sampleCount; } } private void Update() { for (int i = 0; i < waveFormArray.Length - 1; i++) { //      Vector3 upLine = new Vector3(i * 0.01f, waveFormArray[i] * 10, 0); //      Vector3 downLine = new Vector3(i * 0.01f, -waveFormArray[i] * 10, 0); // Debug  Debug.DrawLine(upLine, downLine, Color.green); } // ""  .       int currentPosition = (myAudio.timeSamples / quality) * 2; Vector3 drawVector = new Vector3(currentPosition * 0.01f, 0, 0); Debug.DrawLine(drawVector - Vector3.up * debugLineWidth, drawVector + Vector3.up * debugLineWidth, Color.white); } }

और यहाँ परिणाम है:

PolygonCollider2D के साथ एक चिकनी साउंडस्केप बनाएं

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

ट्रैक को निष्क्रिय करने के लिए, हमें अपना डेटा सुचारू करना होगा। सभी चोटियाँ गायब हो जाती हैं और आप व्यावहारिक रूप से "अपने संगीत को महसूस करना" बंद कर देते हैं
आमतौर पर, संगीत ट्रैक अत्यधिक संकुचित होते हैं और एक ध्वनि ईंट का प्रतिनिधित्व करते हैं, जो एक 2D गेम के लिए खराब रूप से अनुकूल है।
हमारे परिवहन की गति का अनसुलझा मुद्दा, जो ट्रैक की गति के लिए उपयुक्त होना चाहिए। मैं इस मुद्दे पर अगले लेख में विचार करना चाहता हूं।

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

इसलिए, हमें अपने डेटा का उपयोग करके PolygonCollider2D बनाने की आवश्यकता है। यह करना आसान है। PolygonCollider2D में एक सार्वजनिक बिंदु फ़ील्ड है जो वेक्टर 2 [] को स्वीकार करता है। सबसे पहले, हमें अपने बिंदुओं को वांछित प्रकार के वैक्टर में स्थानांतरित करना होगा। आइए अपने नमूनों के सरणी को वेक्टर सरणी में अनुवाद करने के लिए एक फ़ंक्शन बनाएं:

 private Vector2[] CreatePath(float[] src) { Vector2[] result = new Vector2[src.Length]; for (int i = 0; i < size; i++) { result[i] = new Vector2(i * 0.01f, Mathf.Abs(src[i] * lineScale)); } return result; }

उसके बाद, बस हमारे परिणामस्वरूप वैक्टर के पास कोलाइडर को पास करें:

 path = CreatePath(waveFormArray); poly.points = path;

हम परिणाम को देखते हैं। यहाँ हमारे ट्रैक की शुरुआत है ... हम्म ... यह बहुत ही निष्क्रिय नहीं लगता (अभी तक विज़ुअलाइज़ेशन के बारे में मत सोचो, टिप्पणी बाद में आएगी)।

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

एकता में, एल्गोरिथ्म निम्नानुसार कार्यान्वित किया गया है:

 private float[] MovingAverage(int frameSize, float[] data) { float sum = 0; float[] avgPoints = new float[data.Length - frameSize + 1]; for (int counter = 0; counter <= data.Length - frameSize; counter++) { int innerLoopCounter = 0; int index = counter; while (innerLoopCounter < frameSize) { sum = sum + data[index]; innerLoopCounter += 1; index += 1; } avgPoints[counter] = sum / frameSize; sum = 0; } return avgPoints; }

हम अपने पथ निर्माण को संशोधित करते हैं:

 float[] avgArray = MovingAverage(frameSize, waveFormArray); path = CreatePath(avgArray); poly.points = path;

जाँच हो रही है ...

अब हमारा ट्रैक काफी सामान्य लग रहा है। मैंने 10 की विंडो चौड़ाई का उपयोग किया है। आप इस पैरामीटर को संशोधित कर सकते हैं ताकि आपको आवश्यक चौरसाई चुन सकें।

इस खंड की पूरी स्क्रिप्ट इस प्रकार है:

 using UnityEngine; public class WaveFormTest : MonoBehaviour { private const int frameSize = 10; public int size = 2048; public PolygonCollider2D poly; private readonly int lineScale = 5; private readonly int quality = 100; private int sampleCount = 0; private float[] waveFormArray; private float[] samples; private Vector2[] path; private AudioSource myAudio; private void Start() { myAudio = gameObject.GetComponent<AudioSource>(); int freq = myAudio.clip.frequency; sampleCount = freq / quality; samples = new float[myAudio.clip.samples * myAudio.clip.channels]; myAudio.clip.GetData(samples, 0); waveFormArray = new float[(samples.Length / sampleCount)]; for (int i = 0; i < waveFormArray.Length; i++) { waveFormArray[i] = 0; for (int j = 0; j < sampleCount; j++) { waveFormArray[i] += Mathf.Abs(samples[(i * sampleCount) + j]); } waveFormArray[i] /= sampleCount * 2; } //  ,    frameSize float[] avgArray = MovingAverage(frameSize, waveFormArray); path = CreatePath(avgArray); poly.points = path; } private Vector2[] CreatePath(float[] src) { Vector2[] result = new Vector2[src.Length]; for (int i = 0; i < size; i++) { result[i] = new Vector2(i * 0.01f, Mathf.Abs(src[i] * lineScale)); } return result; } private float[] MovingAverage(int frameSize, float[] data) { float sum = 0; float[] avgPoints = new float[data.Length - frameSize + 1]; for (int counter = 0; counter <= data.Length - frameSize; counter++) { int innerLoopCounter = 0; int index = counter; while (innerLoopCounter < frameSize) { sum = sum + data[index]; innerLoopCounter += 1; index += 1; } avgPoints[counter] = sum / frameSize; sum = 0; } return avgPoints; } }

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

शायद आप में से कई, स्क्रीनशॉट को देखकर आश्चर्यचकित थे कि मैंने ट्रैक को कैसे आकर्षित किया? सब के बाद, कोलाइडर दिखाई नहीं दे रहे हैं।

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

समापन

इस लेख में हमने जो सीखा वह संगीत खेलों के लिए एक बुनियादी स्केच है। हां, इस रूप में यह अब तक, थोड़ा बदसूरत है, लेकिन आप सुरक्षित रूप से कह सकते हैं "दोस्तों, मैंने मशीन को ऑडियो ट्रैक के साथ जाना है!"। इसे एक वास्तविक खेल बनाने के लिए, आपको बहुत प्रयास करने की आवश्यकता है। यहाँ हम क्या कर सकते हैं की एक सूची है:

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

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

यूनिटी 3 डी में ध्वनि और संगीत आधारित पर्यावरण पीढ़ी। भाग 2. संगीत से 2 डी ट्रैक बनाना