एकता + डॉट्स पर सैकड़ों हजारों कणों का भौतिक अनुकरण

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



परिणाम इस प्रकार है:


इसे प्राप्त करने के लिए, आपको निम्नलिखित समस्याओं को हल करने की आवश्यकता है:

• कण भौतिकी का वर्णन करें;
• प्रत्येक फ्रेम पर स्थिति गणना की इष्टतम गति सुनिश्चित करें;
• स्क्रीन पर बड़ी संख्या में कणों को जल्दी से आकर्षित करने का एक तरीका चुनें।

भौतिक विज्ञान

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

प्रारंभिक स्थिति के लिए दूरी को कम करना

कण को ​​उसकी मूल स्थिति में लौटने के लिए प्रयास करने के लिए, हुक का नियम हमारे लिए उपयुक्त है : प्रारंभिक स्थिति के लिए निर्देशित बल उसके लिए दूरी के रैखिक रूप से आनुपातिक होगा। कण प्रारंभिक स्थिति से दो गुना दूर उड़ गया - दो बार मजबूत यह "पीछे" खींचता है, सब कुछ सरल है।

कर्सर से दूरी

दिलचस्प होने के लिए, कणों को किसी तरह कर्सर के साथ बातचीत करनी चाहिए, खुद को शुरुआती स्थिति से "पुश" करने की अनुमति दें। मैंने इस संपर्क के आधार के रूप में विपरीत संकेत के साथ गुरुत्वाकर्षण लिया : कणों को माउस कर्सर की स्थिति और कण की वर्तमान स्थिति के बीच की दूरी के वर्ग के लिए आनुपातिक रूप से एक बल द्वारा निरस्त किया जाएगा और कण से कण तक वेक्टर के साथ निर्देशित किया जाएगा।$$$F = -C/r^2$ , जहां$$$C$ एक निश्चित स्थिरांक है जो अंतःक्रिया को नियंत्रित करता है।

क्षीणन

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

परिणाम

परिणामस्वरूप, हम समय पर एक अनियंत्रित क्षण में कण पर अभिनय करने वाले बल का सूत्र प्राप्त करते हैं:

$$

$$\vec{F}_s=C_a*(\vec{x}-\vec{x}_0)-\frac{C_r}{||\vec{x}-\vec{x}_r||^2}*\frac{\vec{x}-\vec{x}_r}{||\vec{x}-\vec{x}_r||}-C_d*\vec{v},$$

कहाँ पे $$$x, v$- वर्तमान स्थिति और कण वेग,$$$x_0$ प्रारंभिक स्थिति है,$$$x_r$ - कर्सर स्थिति,$$$C_a, C_r, C_d$ क्रमशः आकर्षण, प्रतिकर्षण और क्षीणन के गुणांक हैं।

प्रोग्रामिंग व्यवहार

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

डॉट्स एकता इंजन का एक अपेक्षाकृत हालिया विकास है, एक प्रौद्योगिकी ढेर जो उच्च-प्रदर्शन बहु-थ्रेडेड कोड लिखने पर केंद्रित है। Habré पर DOTS में परिचयात्मक लेख का अनुवाद है । ईसीएस , जॉब्स सिस्टम आर्किटेक्चरल पैटर्न और बर्स्ट कंपाइलर के उपयोग के लिए धन्यवाद , डीओटीएस तेजी से बहु-थ्रेडेड कोड लिखना संभव बनाता है, जबकि पैर में एक शॉट की संभावना को कम करता है।

ईसीएस के ढांचे के भीतर एक कार्यक्रम लिखने का सार कोड को घटकों ( घटकों ) में विभाजित करना है जो राज्य, सिस्टम ( सिस्टम ) का वर्णन करते हैं जो घटकों के व्यवहार और बातचीत का वर्णन करते हैं, और एंटिटीज - ऑब्जेक्ट जिसमें घटकों का एक सेट होता है।

अवयव

हमें निम्नलिखित घटकों की आवश्यकता होगी:

//    ( )
public struct AttractorPosData : IComponentData
{
   public float2 Value;
}

//  
public struct VelocityData : IComponentData
{
   public float2 Value;
} 

//  
public struct AccelerationData : IComponentData
{
   public float2 Value;
}

//   
public struct ParticleData : IComponentData 
{
    public Color color;
    public Matrix4x4 matrix;
}

घटकों के साथ, सब कुछ काफी सरल है, सिस्टम पर जाएं:

//   
[UpdateBefore(typeof(MoveSystem))]
public class VelocityUpdateSystem : SystemBase
{
    protected override void OnUpdate()
    {
        var time = Time.DeltaTime;
        Entities.ForEach((ref VelocityData velocity, 
                in AccelerationData acceleration) =>
            {
                velocity.Value += time * acceleration.Value;
            })
            .ScheduleParallel();
    }
}

//   
public class MoveSystem : SystemBase
{
    protected override void OnUpdate()
    {
        var time = Time.DeltaTime;
        Entities.ForEach((ref Translation t, in VelocityData velocity) =>
            {
                t.Value.xy += time * velocity.Value;
            })
            .ScheduleParallel();
    }
}

आप विशेषताओं का उपयोग करके सिस्टम के अनुक्रम को नियंत्रित कर सकते हैं

[UpdateBeforeAttribute]
[UpdateAfterAttribute]

व्यवहार का वर्णन करने वाली सबसे बड़ी प्रणाली त्वरण अद्यतन प्रणाली होगी, जो व्युत्पन्न सूत्र के अनुसार कार्य करती है :

[UpdateBefore(typeof(VelocityUpdateSystem))]
public class AccelerationSystem : SystemBase
{
    protected override void OnUpdate()
    {
        float2 repulsorPos = Globals.Repulsor.Position;

        //   
        var attractionPower = Globals.SettingsHolder.SettingsModel.Attraction;
        //  
        var repulsionPower = Globals.SettingsHolder.SettingsModel.Repulsion;
        //  
        var dampingPower = Globals.SettingsHolder.SettingsModel.Damping;
        Entities.ForEach((
                ref AccelerationData acceleration, 
                in AttractorPosData attractorPos, 
                in Translation t,
                in VelocityData velocity) =>
            {
                //  
                var attraction = (attractorPos.Value - t.Value.xy) * attractionPower;

                var distSqr = math.distancesq(repulsorPos, t.Value.xy);
                //  
                var repulsion = -math.normalizesafe(repulsorPos - t.Value.xy) 
                    / distSqr * repulsionPower;

                //  
                var damping = -velocity.Value * dampingPower;

                acceleration.Value = attraction + repulsion + damping;
            })
            .ScheduleParallel();
    }
}

प्रस्तुत करना

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

मानक यूनिटी शैडर "स्प्राइट्स / डिफाल्ट" जीपीओ इंस्टेंसिंग का उपयोग असमान स्प्राइट्स और रंगों के साथ वस्तुओं के प्रतिपादन को अनुकूलित करने के लिए कर सकता है , उन्हें एक ड्रॉ कॉल में संयोजित कर सकता है, लेकिन इस मामले में, प्रत्येक विशिष्ट वस्तु के लिए बनावट और रंग का लिंक एक स्क्रिप्ट से सेट किया जाना चाहिए, जिससे ECS से हमारी पहुँच नहीं है।

समाधान Graphics.DrawMeshInstanced मेथड हो सकता है, जो आपको एक ही जीपीओ इंस्टेंसिंग का उपयोग करके विभिन्न सामग्री मापदंडों के साथ एक ड्रॉ कॉल में कई बार एक जाल खींचने की अनुमति देता है। यह इस तरह दिख रहा है:

[UpdateAfter(typeof(TrsMatrixCalculationSystem))]
public class SpriteSheetRenderer : SystemBase
{
    // DrawMeshInstanced     1023    
    private const int BatchCount = 1023;
    //   
    private readonly List<Matrix4x4> _matrixList = new List<Matrix4x4>(BatchCount);
    //  
    private readonly List<Vector4> _colorList = new List<Vector4>(BatchCount);

    protected override void OnUpdate()
    {
        var materialPropertyBlock = new MaterialPropertyBlock();
        var quadMesh = Globals.Quad;
        var material = Globals.ParticleMaterial;

        //        
        //   
        var shaderPropertyId = Shader.PropertyToID("_Color");

        var entityQuery = GetEntityQuery(typeof(ParticleData));
        //   ,   ParticleData
        var animationData = 
                   entityQuery.ToComponentDataArray<ParticleData>(Allocator.TempJob);
        var layer = LayerMask.NameToLayer("Particles");

        for (int meshCount = 0; 
              meshCount < animationData.Length; 
              meshCount += BatchCount)
        {
            var batchSize = math.min(BatchCount, animationData.Length - meshCount);
            _matrixList.Clear();
            _colorList.Clear();

            for (var i = meshCount; i < meshCount + batchSize; i++)
            {
                _matrixList.Add(animationData[i].matrix);
                _colorList.Add(animationData[i].color);
            }

            materialPropertyBlock.SetVectorArray(shaderPropertyId, _colorList);
            Graphics.DrawMeshInstanced(
                quadMesh,
                0,
                material,
                _matrixList,
                materialPropertyBlock,
                ShadowCastingMode.Off, false, layer);
        }

        animationData.Dispose();
    }
}

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

[UpdateAfter(typeof(MoveSystem))]
public class TrsMatrixCalculationSystem : SystemBase
{
    protected override void OnUpdate()
    {
        //   scale   
        var scale = Globals.SettingsHolder.SettingsModel.ParticlesScale;
        Entities.ForEach((ref ParticleData data, in Translation translation) =>
            {
                data.matrix = Matrix4x4.TRS(translation.Value, Quaternion.identity,
                    new Vector3(scale, scale, scale));
            })
            .ScheduleParallel();
    }
}

प्रदर्शन

यह बात करने का समय है कि (इसके अलावा, बेशक, सौंदर्य संतुष्टि) यह सब कैसे हुआ। एकता में, इस समय दो स्क्रिप्टिंग बैकेंड ( सीएलआर कार्यान्वयन ) से चुनने का अवसर है : अच्छे पुराने मोनो और एकता डेवलपर्स से एक अधिक आधुनिक समाधान - IL2CPP ।

इन दो रनटाइम कार्यान्वयनों के निर्माण प्रदर्शन की तुलना करें:
पीसी विनिर्देशों:
QHD 2560x1440
इंटेल कोर i5-9600K
16 जीबी रैम
MSI GeForce RTX 2080 सुपर वेंट एक्सयूएस 8.0 जीबी


160,000 कण

यह ध्यान देने योग्य है कि, इस गोलाकार वैक्यूम प्रयोग में, IL2CPP आउटपरफॉर्मो मोनो के बारे में दो बार।

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

एकता संपादक


बिल्ड

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

// 
public struct ParticleData : IComponentData
{
    public Color color;
    public Matrix4x4 matrix;
}
// 
public struct ParticleData : IComponentData
{
    public Vector4 color;
    public Matrix4x4 matrix;
}

इस परिवर्तन ने हमें महंगे रूपांतरण ऑपरेशन से पूरी तरह से छुटकारा पाने की अनुमति दी:

200,000 कणों के लिए प्रति सेकंड फ्रेम की संख्या बढ़कर 61 हो गई।

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

निष्कर्ष

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

पुनश्च

हर कोई मेरे गिटबॉस भंडार में परियोजना से परिचित हो सकता है , लेकिन वॉलपेपर इंजन में डेस्कटॉप वॉलपेपर के रूप में निर्माण कैसे स्थापित करें : लिंक ।