वीडियो कार्ड के किनारे कंकाल एनीमेशन

एकता ने हाल ही में ईसीएस की शुरुआत की। अध्ययन की प्रक्रिया में, मुझे इस बात में दिलचस्पी हो गई कि एनीमेशन और ईसीएस को कैसे दोस्त बनाया जा सकता है। और खोज प्रक्रिया में, मुझे एक दिलचस्प तकनीक के बारे में पता चला, जो कि NORDVEUS के लोगों ने यूनाइट ऑस्टिन 2017 रिपोर्ट के लिए अपने डेमो में इस्तेमाल किया था।
यूनाइट ऑस्टिन 2017 - स्पेलसल्स यूनिवर्स में बड़े पैमाने पर लड़ाई।

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

ऐसी मुश्किलें, आप क्यों पूछते हैं?

NORDVEUS के लोग एक साथ स्क्रीन पर एक ही प्रकार की एनिमेटेड ऑब्जेक्ट की एक बड़ी संख्या में चित्रित करते हैं: कंकाल, तलवारबाज। पारंपरिक दृष्टिकोण का उपयोग करने के मामले में: SkinnedMeshRenderers और एनिमेशन \ एनीमेटर , ड्रॉ कॉल में वृद्धि और एनीमेशन को रेंडर करने के लिए सीपीयू पर एक अतिरिक्त भार देगा। और इन समस्याओं को हल करने के लिए, एनीमेशन को GPU के पक्ष में स्थानांतरित किया गया था, या वर्टेकर shader के बजाय।

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

तो आइए हाथी को टुकड़ों में काटें:

• क्लिप से एनीमेशन कुंजी प्राप्त करना
• डेटा को बनावट में सहेजना
• मेष (मेष) तैयारी
• शेडर
• यह सब एक साथ रखना

एनीमेशन क्लिप से एनीमेशन कुंजी प्राप्त करना

SkinnedMeshRenderers के घटकों से हमें हड्डियों की एक सरणी और एक जाल मिलता है। एनिमेशन घटक उपलब्ध एनिमेशन की एक सूची प्रदान करता है। तो, प्रत्येक क्लिप के लिए, हमें जाल की सभी हड्डियों के लिए फ्रेम द्वारा परिवर्तन मैट्रिक्स फ्रेम को बचाना होगा। दूसरे शब्दों में, हम समय की प्रति इकाई चरित्र की मुद्रा रखते हैं।

हम एक दो-आयामी सरणी का चयन करते हैं जिसमें डेटा संग्रहीत किया जाएगा। एक आयाम जिसमें फ़्रेम की संख्या सेकंड में क्लिप की लंबाई होती है। एक और जाल में हड्डियों की कुल संख्या है:

var boneMatrices = new Matrix4x4[Mathf.CeilToInt(frameRate * clip.length), renderer.bones.Length]; 

निम्नलिखित उदाहरण में, हम क्लिप के लिए एक-एक करके फ्रेम बदलते हैं और मैट्रीस को बचाते हैं:

 //       for (var frameIndex = 0; frameIndex < totalFramesInClip; ++frameIndex) { //  : 0 -  , 1 - . var normalizedTime = (float) frameIndex / totalFramesInClip; //     animationState.normalizedTime = normalizedTime; animation.Sample(); //     for (var boneIndex = 0; j < renderer.bones.Length; boneIndex++) { //         var matrix = renderer.bones[boneIndex].localToWorldMatrix * renderer.sharedMesh.bindposes[boneIndex]; //   boneMatrices[i, j] = matrix; } } 

मैट्रिक्स 4 से 4 हैं, लेकिन अंतिम पंक्ति हमेशा (0, 0, 0, 1) की तरह लगती है। इसलिए, मामूली अनुकूलन के उद्देश्य के लिए, इसे छोड़ दिया जा सकता है। जो बदले में प्रोसेसर और वीडियो कार्ड के बीच डेटा ट्रांसफर की लागत को कम करेगा।

 a00 a01 a02 a03 a10 a11 a12 a13 a20 a21 a22 a23 0 0 0 1 

डेटा को बनावट में सहेजना

बनावट के आकार की गणना करने के लिए, हम सभी एनीमेशन क्लिप में हड्डियों की संख्या और मैट्रिक्स में पंक्तियों की संख्या से फ्रेम की कुल संख्या को गुणा करते हैं (हम सहमत थे कि हम पहले 3 पंक्तियों को बचाते हैं)।

 var dataSize = numberOfBones * numberOfKeyFrames * MATRIX_ROWS_COUNT); //      var size = NextPowerOfTwo((int) Math.Sqrt(dataSize)); var texture = new Texture2D(size, size, TextureFormat.RGBAFloat, false) { wrapMode = TextureWrapMode.Clamp, filterMode = FilterMode.Point, anisoLevel = 0 }; 

हम डेटा को बनावट में लिखते हैं। प्रत्येक क्लिप के लिए, हम फ्रेम द्वारा परिवर्तन मैट्रिक्स फ्रेम को बचाते हैं। डेटा प्रारूप इस प्रकार है। क्लिप क्रमिक रूप से एक-एक करके रिकॉर्ड किए जाते हैं और फ़्रेम का एक सेट होता है। जो बदले में हड्डियों के एक सेट से मिलकर बनता है। प्रत्येक हड्डी में मैट्रिक्स की 3 पंक्तियाँ होती हैं।

 Clip0[Frame0[Bone0[row0,row1,row2]...BoneN[row0,row1,row2].]...FramM[bone0[row0,row1,row2]...ClipK[...] 

निम्नलिखित कोड सहेजें है:

 var textureColor = new Color[texture.width * texture.height]; var clipOffset = 0; for (var clipIndex = 0; clipIndex < sampledBoneMatrices.Count; clipIndex++) { var framesCount = sampledBoneMatrices[clipIndex].GetLength(0); for (var keyframeIndex = 0; keyframeIndex < framesCount; keyframeIndex++) { var frameOffset = keyframeIndex * numberOfBones * 3; for (var boneIndex = 0; boneIndex < numberOfBones; boneIndex++) { var index = clipOffset + frameOffset + boneIndex * 3; var matrix = sampledBoneMatrices[clipIndex][keyframeIndex, boneIndex]; textureColor[index + 0] = matrix.GetRow(0); textureColor[index + 1] = matrix.GetRow(1); textureColor[index + 2] = matrix.GetRow(2); } } } texture.SetPixels(textureColor); texture.Apply(false, false); 

मेष (मेष) की तैयारी

बनावट निर्देशांक का एक अतिरिक्त सेट जोड़ें, जिसके लिए प्रत्येक शीर्ष पर हम संबंधित हड्डी सूचकांकों और इस शीर्ष पर हड्डी के प्रभाव के वजन को बचाते हैं।
एकता एक डेटा संरचना प्रदान करती है जिसमें एक शीर्ष के लिए 4 हड्डियां संभव हैं। नीचे इस डेटा को uv पर लिखने के लिए कोड है। हम UV1 में हड्डियों के सूचकांकों को बचाते हैं, यूवी 2 में वजन करते हैं।

 var boneWeights = mesh.boneWeights; var boneIds = new List<Vector4>(mesh.vertexCount); var boneInfluences = new List<Vector4>(mesh.vertexCount); for (var i = 0; i < mesh.vertexCount; i++) { boneIds.Add(new Vector4(bw.boneIndex0, bw.boneIndex1, bw.boneIndex2, bw.boneIndex3); boneInfluences.Add(new Vector4(bw.weight0, bw.weight1, bw.weight2, bw.weight3)); } mesh.SetUVs(1, boneIds); mesh.SetUVs(2, boneInfluences); 

शेडर

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

 // frameOffset = clipOffset + frameIndex * clipLength * 3 -     CPU // boneIndex -      ,   UV1 int index = frameOffset + boneIndex * 3; 

तो हमें मैट्रिक्स की पहली पंक्ति का सूचकांक मिला, दूसरे और तीसरे का सूचकांक क्रमशः +1, +2 होगा। यह बनावट के सामान्यीकृत निर्देशांक में एक-आयामी सूचकांक का अनुवाद करने के लिए रहता है और इसके लिए हमें बनावट के आकार की आवश्यकता होती है।

 inline float4 IndexToUV(int index, float2 size) { return float4(((float)((int)(index % size.x)) + 0.5) / size.x, ((float)((int)(index / size.x)) + 0.5) / size.y, 0, 0); } 

पंक्तियों को घटाए जाने के बाद, हम पिछली पंक्ति के बारे में भूलकर मैट्रिक्स एकत्र करते हैं, जो हमेशा (0, 0, 0, 1) के बराबर होता है।

 float4 row0 = tex2Dlod(frameOffset, IndexToUV(index + 0, animationTextureSize)); float4 row1 = tex2Dlod(frameOffset, IndexToUV(index + 1, animationTextureSize)); float4 row2 = tex2Dlod(frameOffset, IndexToUV(index + 2, animationTextureSize)); float4 row3 = float4(0, 0, 0, 1); return float4x4(row0, row1, row2, row3); 

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

 float4x4 m0 = CreateMatrix(frameOffset, bones.x) * boneInfluences.x; float4x4 m1 = CreateMatrix(frameOffset, bones.y) * boneInfluences.y; float4x4 m2 = CreateMatrix(frameOffset, bones.z) * boneInfluences.z; float4x4 m3 = CreateMatrix(frameOffset, bones.w) * boneInfluences.w; return m0 + m1 + m2 + m3; 

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

यह सब एक साथ रखना

वस्तुओं को प्रदर्शित करने के लिए, हम Graphics.DrawMeshInstancedIndirect का उपयोग करेंगे, जिसमें हम तैयार जाल और सामग्री को स्थानांतरित करेंगे। इसके अलावा, सामग्री में, हमें टेक्सचर साइज के लिए टेक्सचर को पास करना होगा और मौजूदा समय में प्रत्येक ऑब्जेक्ट के लिए फ्रेम के साथ पॉइंटर्स के साथ एक सरणी। अतिरिक्त जानकारी के रूप में, हम प्रत्येक ऑब्जेक्ट और रोटेशन के लिए स्थिति को पास करते हैं। स्थिति को बदलने के लिए और शेडर साइड पर रोटेशन को [लेख] में पाया जा सकता है।

अद्यतन विधि में, समय की अवधि बढ़ाएँ एनीमेशन की शुरुआत से Time.deltaTime पर।

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

 var offset = clipStart + frameIndex * bonesCount * 3.0f 

शायद यह सभी shader को सभी डेटा पास कर रहा है, हम Graphics.DrawMeshInstancedIndirect को तैयार जाल और सामग्री के साथ कहते हैं।

निष्कर्ष

1050 ग्राफिक्स कार्ड वाली मशीन पर इस तकनीक का परीक्षण करने पर लगभग 2 गुना का प्रदर्शन बढ़ा।

सीपीयू पर एक ही प्रकार की 4000 वस्तुओं का एनीमेशन

GPU पर एक ही प्रकार की 8000 वस्तुओं का एनीमेशन

उसी समय, एक एकीकृत ग्राफिक्स कार्ड के साथ मैकबुक प्रो 15 पर इस दृश्य का परीक्षण विपरीत परिणाम दिखाता है। GPU बेशर्मी से हार जाता है (लगभग 2-3 बार), जो आश्चर्यजनक नहीं है।

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

संदर्भ

• एनीमेशन इंस्टेंसिंग - स्किनमेडमेशरेंडर के लिए इंस्टेंस
• GPUSkinning - प्रदर्शन में सुधार।
• यूनाइटएस्टाइनटेक्निकलप्रेशेंटेशन - ईसीएस डेमो

आपका ध्यान के लिए धन्यवाद।

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