Prestatieaanaanveling voor Unity

Dit artikel bouwt voort op de prestatieaanbeveling voor mixed reality, maar richt zich op Unity-specifieke verbeteringen.

We hebben onlangs een toepassing uitgebracht met de naam Quality Fundamentals die betrekking heeft op veelvoorkomende prestatie-, ontwerp- en omgevingsproblemen en oplossingen voor HoloLens 2-apps. Deze app is een geweldige visuele demo voor de inhoud die volgt.

De belangrijkste eerste stap bij het optimaliseren van de prestaties van mixed reality-apps in Unity is ervoor te zorgen dat u de aanbevolen omgevingsinstellingen voor Unity gebruikt. Dit artikel bevat inhoud met enkele van de belangrijkste scèneconfiguraties voor het bouwen van krachtige Mixed Reality-apps. Sommige van deze aanbevolen instellingen worden hieronder ook gemarkeerd.

Profileer met Unity

Unity biedt de ingebouwde Unity Profiler , een uitstekende resource voor het verzamelen van waardevolle prestatie-inzichten voor uw specifieke app. Hoewel u de profiler in de editor kunt uitvoeren, vertegenwoordigen deze metrische gegevens niet de echte runtime-omgeving, zodat de resultaten voorzichtig moeten worden gebruikt. We raden u aan uw toepassing extern te profileren terwijl deze wordt uitgevoerd op het apparaat voor de meest nauwkeurige en bruikbare inzichten. Bovendien is Het Frame Debugger van Unity ook een krachtig en inzichthulpprogramma dat u kunt gebruiken.

Notitie

Unity biedt de mogelijkheid om de doelresolutie van uw toepassing tijdens runtime te wijzigen via de eigenschap XRSettings.renderViewportScale . De uiteindelijke afbeelding die op het apparaat wordt weergegeven, heeft een vaste resolutie. Het platform zal de uitvoer van de lagere resolutie samplen om een afbeelding met een hogere resolutie te bouwen voor rendering op beeldschermen.

UnityEngine.XR.XRSettings.renderViewportScale = 0.7f;

Unity biedt geweldige documentatie voor:

  1. De Unity Profiler op afstand verbinden met UWP-toepassingen
  2. Prestatieproblemen met unity profiler effectief diagnosticeren

Notitie

Wanneer de Unity Profiler is verbonden en nadat u de GPU-profiler hebt toegevoegd (zie Profiler toevoegen in de rechterbovenhoek), kunt u zien hoeveel tijd er wordt besteed aan respectievelijk de CPU GPU & in het midden van de profiler. Hierdoor kan de ontwikkelaar een snelle benadering krijgen als de toepassing CPU of GPU is gebonden.

Unity CPU vs GPU

Aanbevelingen voor CPU-prestaties

De onderstaande inhoud bevat gedetailleerdere prestatieprocedures, met name gericht op Unity & C#-ontwikkeling.

Cacheverwijzingen

We raden u aan verwijzingen in de cache op te slaan naar alle relevante onderdelen en GameObjects tijdens de initialisatie, omdat herhalende functie-aanroepen zoals GetComponentT<>() en Camera.main duurder zijn ten opzichte van de geheugenkosten om een aanwijzer op te slaan. . Camera.main maakt alleen gebruik van FindGameObjectsWithTag() eronder, die duur zoekt in uw scènegrafiek naar een cameraobject met de tag 'MainCamera' .

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour
{
    private Camera cam;
    private CustomComponent comp;

    void Start() 
    {
        cam = Camera.main;
        comp = GetComponent<CustomComponent>();
    }

    void Update()
    {
        // Good
        this.transform.position = cam.transform.position + cam.transform.forward * 10.0f;

        // Bad
        this.transform.position = Camera.main.transform.position + Camera.main.transform.forward * 10.0f;

        // Good
        comp.DoSomethingAwesome();

        // Bad
        GetComponent<CustomComponent>().DoSomethingAwesome();
    }
}

Notitie

Vermijd GetComponent(tekenreeks)
Wanneer u GetComponent() gebruikt, zijn er een aantal verschillende overbelastingen. Het is belangrijk om altijd de implementaties op basis van type te gebruiken en nooit de op tekenreeks gebaseerde zoekbelasting. Zoeken op tekenreeks in uw scène is aanzienlijk duurder dan zoeken op type.
(Goed) Component GetComponent(type)
(Goed) T GetComponentT<>()
(Slecht) Component GetComponent(tekenreeks)>

Vermijd dure bewerkingen

  1. Vermijd het gebruik van LINQ

    Hoewel LINQ schoon en gemakkelijk kan worden gelezen en geschreven, vereist het over het algemeen meer rekenkracht en geheugen dan als u het algoritme handmatig hebt geschreven.

    // Example Code
    using System.Linq;
    
    List<int> data = new List<int>();
    data.Any(x => x > 10);
    
    var result = from x in data
                 where x > 10
                 select x;
    
  2. Algemene Unity-API's

    Bepaalde Unity-API's, hoewel nuttig, kunnen duur zijn om uit te voeren. De meeste hiervan zijn het doorzoeken van uw hele scènegrafiek voor een overeenkomende lijst met GameObjects. Deze bewerkingen kunnen over het algemeen worden vermeden door verwijzingen in cache te plaatsen of een manageronderdeel voor de GameObjects te implementeren om de verwijzingen tijdens runtime bij te houden.

        GameObject.SendMessage()
        GameObject.BroadcastMessage()
        UnityEngine.Object.Find()
        UnityEngine.Object.FindWithTag()
        UnityEngine.Object.FindObjectOfType()
        UnityEngine.Object.FindObjectsOfType()
        UnityEngine.Object.FindGameObjectsWithTag()
        UnityEngine.Object.FindGameObjectsWithTag()
    

Notitie

SendMessage() en BroadcastMessage() moeten ten koste van alle kosten worden geëlimineerd. Deze functies kunnen in de volgorde van 1000x langzamer zijn dan directe functieaanroepen.

  1. Pas op voor boksen

    Boksen is een kernconcept van de C#-taal en runtime. Het is het proces van het verpakken van variabelen met een waardetype, zoals char, intbool, , enzovoort, in variabelen met verwijzingstypen. Wanneer een variabele met een waardetype 'boxed' is, wordt deze verpakt in een System.Object, die is opgeslagen op de beheerde heap. Geheugen wordt toegewezen en moet uiteindelijk worden verwerkt door de garbagecollector. Voor deze toewijzingen en deallocaties zijn prestatiekosten nodig en in veel scenario's zijn ze overbodig of kunnen ze eenvoudig worden vervangen door een goedkoper alternatief.

    Om boksen te voorkomen, moet u ervoor zorgen dat de variabelen, velden en eigenschappen waarin u numerieke typen en structs (inclusief Nullable<T>) opslaat, sterk zijn getypt als specifieke typen, zoals int, float? of MyStruct, in plaats van object te gebruiken. Als u deze objecten in een lijst plaatst, moet u een sterk getypte lijst gebruiken, zoals List<int> in plaats List<object> van of ArrayList.

    Voorbeeld van boksen in C #

    // boolean value type is boxed into object boxedMyVar on the heap
    bool myVar = true;
    object boxedMyVar = myVar;
    

Herhalende codepaden

Herhalende Unity-callbackfuncties (bijvoorbeeld Update) die meerdere keren per seconde en/of frame worden uitgevoerd, moeten zorgvuldig worden geschreven. Dure bewerkingen hier hebben enorme en consistente invloed op de prestaties.

  1. Lege callback-functies

    Hoewel de onderstaande code onschuldig kan lijken om in uw toepassing te blijven, met name omdat elk Unity-script automatisch initialiseert met een updatemethode, kunnen deze lege callbacks duur worden. Unity werkt heen en weer tussen een onbeheerde en beheerde codegrens, tussen UnityEngine-code en uw toepassingscode. Het overschakelen van context over deze brug is redelijk duur, zelfs als er niets moet worden uitgevoerd. Dit wordt vooral problematisch als uw app 100s GameObjects heeft met onderdelen met lege herhalende Unity-callbacks.

    void Update()
    {
    }
    

Notitie

Update() is de meest voorkomende manifestatie van dit prestatieprobleem, maar andere herhalende Unity-callbacks, zoals het volgende, kunnen even slecht zijn, als dat niet erger is: FixedUpdate(), LateUpdate(), OnPostRender", OnPreRender(), OnRenderImage(), enzovoort.

  1. Bewerkingen om één keer per frame te worden uitgevoerd

    De volgende Unity-API's zijn algemene bewerkingen voor veel Holographic Apps. Hoewel het niet altijd mogelijk is, kunnen de resultaten van deze functies vaak eenmaal worden berekend en kunnen de resultaten opnieuw worden gebruikt in de toepassing voor een bepaald frame.

    a) Het is een goede gewoonte om een speciale Singleton-klasse of -service te hebben om raycast in de scène te verwerken en dit resultaat vervolgens opnieuw te gebruiken in alle andere scèneonderdelen, in plaats van herhaalde en identieke Raycast-bewerkingen per onderdeel te maken. Sommige toepassingen vereisen mogelijk raycasts van verschillende origins of tegen verschillende LayerMasks.

        UnityEngine.Physics.Raycast()
        UnityEngine.Physics.RaycastAll()
    

    b) Vermijd GetComponent() bewerkingen in herhaalde Unity-callbacks, zoals Update() door verwijzingen in de cache op te zetten in Start() of Awake()

        UnityEngine.Object.GetComponent()
    

    c) Het is een goede gewoonte om bij het initialiseren en gebruiken van objectgroepering alle objecten bij het initialiseren en gebruiken van objectgroepen om GameObjects gedurende de runtime van uw toepassing te recyclen en opnieuw te gebruiken

        UnityEngine.Object.Instantiate()
    
  2. Interfaces en virtuele constructies voorkomen

    Het aanroepen van functie-aanroepen via interfaces versus directe objecten of het aanroepen van virtuele functies kan vaak veel duurder zijn dan het gebruik van directe constructies of directe functie-aanroepen. Als de virtuele functie of interface niet nodig is, moet deze worden verwijderd. De prestatietreffers voor deze benaderingen zijn echter de moeite waard als het gebruik ervan de ontwikkeling vereenvoudigt, de leesbaarheid van code en de onderhoudbaarheid van code.

    Over het algemeen is het raadzaam om velden en functies niet als virtueel te markeren, tenzij er een duidelijke verwachting is dat dit lid moet worden overschreven. Een moet vooral voorzichtig zijn rond codepaden met een hoge frequentie die vaak per frame of zelfs eenmaal per frame worden aangeroepen, zoals een UpdateUI() methode.

  3. Vermijd het doorgeven van structs op waarde

    In tegenstelling tot klassen zijn structs waardetypen en wanneer ze rechtstreeks aan een functie worden doorgegeven, worden de inhoud gekopieerd naar een zojuist gemaakte instantie. Met deze kopie worden CPU-kosten en extra geheugen op de stack toegevoegd. Voor kleine structs is het effect minimaal en dus acceptabel. Voor functies die echter herhaaldelijk elk frame hebben aangeroepen, evenals functies die grote structs gebruiken, wijzigt u indien mogelijk de functiedefinitie zodat deze wordt doorgegeven doorverwijzing. Klik hier voor meer informatie

Diversen

  1. Natuurkunde

    a) Over het algemeen is de eenvoudigste manier om de fysica te verbeteren de hoeveelheid tijd die is besteed aan de natuurkunde of het aantal iteraties per seconde te beperken. Dit vermindert de nauwkeurigheid van de simulatie. Zie TimeManager in Unity

    b) De typen colliders in Unity hebben veel verschillende prestatiekenmerken. In de onderstaande volgorde worden de meest presterende colliers vermeld voor de minst presterende colliers van links naar rechts. Het is belangrijk om Mesh Colliders te vermijden, die aanzienlijk duurder zijn dan de primitieve colliers.

    Sphere < Capsule < Box <<< Mesh (Convex) < Mesh (niet-Convex)

    Zie best practices voor Unity Physics voor meer informatie

  2. Animaties

    Schakel niet-actieve animaties uit door het onderdeel Hiermee uit te schakelen (als u het gameobject uitschakelt, heeft dit niet hetzelfde effect). Vermijd ontwerppatronen waarbij een docent zich in een lus bevindt, waardoor een waarde op hetzelfde wordt ingesteld. Er is aanzienlijke overhead voor deze techniek, zonder dat dit van invloed is op de toepassing. Klik hier voor meer informatie.

  3. Complexe algoritmen

    Als uw toepassing complexe algoritmen gebruikt, zoals inverse kinematica, padzoekopdrachten, enzovoort, zoekt u naar een eenvoudigere benadering of past u relevante instellingen aan voor de prestaties

Aanbevelingen voor CPU-naar-GPU-prestaties

Over het algemeen komen de CPU-naar-GPU-prestaties neer op de tekenoproepen die naar de grafische kaart worden verzonden. Om de prestaties te verbeteren, moeten aanroepen strategisch a) verminderd of b) worden geherstructureerd voor optimale resultaten. Omdat het tekenen van aanroepen zelf resource-intensief is, vermindert u het totale werk dat nodig is. Verder vereisen statuswijzigingen tussen aanroepen dure validatie- en vertaalstappen in het grafische stuurprogramma en kunnen de herstructurering van de tekenoproepen van uw toepassing om statuswijzigingen te beperken (d.w.z. verschillende materialen, enzovoort) de prestaties verbeteren.

Unity heeft een geweldig artikel met een overzicht en duikt in batchverwerkingsoproepen voor hun platform.

Single Pass Instanced Rendering

Met Single Pass Instanced Rendering in Unity kunnen aanroepen voor elk oog worden verkleind tot één aanroep voor het tekenen. Vanwege de coherentie van de cache tussen twee aanroepen tekenen, is er ook een prestatieverbetering voor de GPU.

Deze functie inschakelen in uw Unity-Project

  1. Open Player XR-Instellingen (ga naar Bewerken>Project Instellingen>PlayerXR-Instellingen>)
  2. Selecteer Single Pass Instanced in de vervolgkeuzelijst Stereo Rendering Method (het selectievakje Virtual Reality Supported moet zijn ingeschakeld)

Lees de volgende artikelen uit Unity voor meer informatie met deze renderingbenadering.

Notitie

Een veelvoorkomend probleem met Single Pass Instanced Rendering treedt op als ontwikkelaars al bestaande aangepaste shaders hebben die niet zijn geschreven voor instancing. Nadat deze functie is ingeschakeld, kunnen ontwikkelaars merken dat sommige GameObjects slechts in één oog worden weergegeven. Dit komt doordat de bijbehorende aangepaste shaders niet over de juiste eigenschappen beschikken om te worden geïnstitueerd.

Zie Single Pass Stereo Rendering voor HoloLens van Unity voor het oplossen van dit probleem

Statische batchverwerking

Unity kan veel statische objecten batcheren om tekenoproepen naar de GPU te verminderen. Statische batchverwerking werkt voor de meeste Renderer-objecten in Unity die 1) hetzelfde materiaal delen en 2) zijn allemaal gemarkeerd als Statisch (Selecteer een object in Unity en schakel het selectievakje in de rechterbovenhoek van de inspector in). GameObjects die zijn gemarkeerd als Statisch , kunnen niet worden verplaatst tijdens de runtime van uw toepassing. Statische batchverwerking kan dus moeilijk worden gebruikt op HoloLens waar vrijwel elk object moet worden geplaatst, verplaatst, geschaald, enzovoort. Voor insluitende headsets kan statische batchverwerking het aantal aanroepen aanzienlijk verminderen en zo de prestaties verbeteren.

Lees statische batchverwerking onder Draw Call Batching in Unity voor meer informatie.

Dynamische batchverwerking

Omdat het problematisch is om objecten te markeren als statisch voor HoloLens ontwikkeling, kan dynamische batchverwerking een geweldig hulpmiddel zijn om deze ontbrekende functie te compenseren. Het kan ook handig zijn voor insluitende headsets. Dynamische batchverwerking in Unity kan echter moeilijk inschakelen omdat GameObjects a) hetzelfde materiaal moeten delen en b) voldoen aan een lange lijst met andere criteria.

Lees dynamische batchverwerking onder Batching tekenen in Unity voor de volledige lijst. GameObjects worden meestal ongeldig om dynamisch te worden gebatcheerd, omdat de bijbehorende mesh-gegevens niet meer dan 300 hoekpunten kunnen zijn.

Andere technieken

Batchverwerking kan alleen optreden als meerdere GameObjects hetzelfde materiaal kunnen delen. Normaal gesproken wordt dit geblokkeerd door de noodzaak voor GameObjects om een unieke textuur voor hun respectieve materiaal te hebben. Het is gebruikelijk om Textures te combineren in één grote texture, een methode die bekend staat als Texture Atlasing.

Bovendien is het beter om waar mogelijk en redelijk meshes te combineren in één GameObject. Elke Renderer in Unity heeft de bijbehorende tekenoproep(en) versus het verzenden van een gecombineerde mesh onder één Renderer.

Notitie

Als u eigenschappen van Renderer.material tijdens runtime wijzigt, wordt er een kopie van het materiaal gemaakt en wordt batchverwerking mogelijk verbroken. Gebruik Renderer.sharedMaterial om gedeelde materiaaleigenschappen in GameObjects te wijzigen.

Aanbevelingen voor GPU-prestaties

Meer informatie over het optimaliseren van grafische rendering in Unity

Bandbreedte- en opvulsnelheden

Bij het weergeven van een frame op de GPU is een toepassing gebonden aan de geheugenbandbreedte of de doorvoersnelheid.

  • Geheugenbandbreedte is de snelheid van leesbewerkingen en schrijfbewerkingen die de GPU kan uitvoeren vanuit het geheugen
  • De opvulsnelheid verwijst naar de pixels die per seconde door de GPU kunnen worden getekend.

Dieptebuffer delen optimaliseren

Het is raadzaam dieptebuffer delen in te schakelen onder Player XR-Instellingen om te optimaliseren voor hologramstabiliteit. Bij het inschakelen van op diepte gebaseerde nieuwe projectie in de late fase met deze instelling, is het echter raadzaam om een 16-bits diepte-indeling te selecteren in plaats van een 24-bits diepteindeling. De 16-bits dieptebuffers verminderen de bandbreedte (en dus stroom) die zijn gekoppeld aan dieptebufferverkeer drastisch. Dit kan een grote winst zijn in zowel energieverbruikvermindering als prestatieverbetering. Er zijn echter twee mogelijke negatieve resultaten met behulp van de 16-bits diepte-indeling.

Z-Fighting

De verminderde betrouwbaarheid van het dieptebereik maakt z-vechten waarschijnlijker met 16 bits dan 24-bits. Om deze artefacten te voorkomen, wijzigt u de knipvlakken van de Unity-camera om rekening te houden met de lagere precisie. Voor op HoloLens gebaseerde toepassingen kan een verre clipvlak van 50 m in plaats van de Unity-standaard 1000 m over het algemeen elke z-fighting elimineren.

Uitgeschakelde stencilbuffer

Wanneer Unity een renderpatroon met 16-bits diepte maakt, is er geen stencilbuffer gemaakt. Als u een 24-bits diepte-indeling selecteert, maakt u per Unity-documentatie een 24-bits z-buffer, evenals een [8-bits stencilbuffer] (https://docs.unity3d.com/Manual/SL-Stencil.html) (als 32-bits van toepassing is op een apparaat, wat in het algemeen het geval is, zoals HoloLens).

Effecten op volledig scherm vermijden

Technieken die op het volledige scherm werken, kunnen duur zijn, omdat hun omvang miljoenen bewerkingen per frame is. Het is raadzaam om naverwerkingseffecten zoals antialiassen , bloei en meer te voorkomen.

Optimale verlichtingsinstellingen

Real-time Global Lighting in Unity kan uitstekende visuele resultaten bieden, maar hiervoor zijn dure belichtingsberekeningen vereist. We raden u aan realtime Global Illumination uit te schakelen voor elk Unity-scènebestand via WindowRenderingLighting>>Instellingen>Realtime Globale verlichting uitschakelen.

Bovendien is het raadzaam om alle schaduwcasting uit te schakelen, omdat deze ook dure GPU-passen toevoegen aan een Unity-scène. Schaduwen kunnen per licht worden uitgeschakeld, maar kunnen ook holistisch worden beheerd via kwaliteitsinstellingen.

Bewerken>Project Instellingen en selecteer vervolgens de categorie >Kwaliteit selecteren Lage kwaliteit voor het UWP-platform. U kunt ook de eigenschap Schaduwen instellen op Schaduwen uitschakelen.

We raden u aan gebakken verlichting te gebruiken met uw modellen in Unity.

Aantal poly beperken

Aantal veelhoeken wordt verminderd door een van beide

  1. Objecten uit een scène verwijderen
  2. Activumdeciatie, waardoor het aantal veelhoeken voor een bepaald mesh wordt verminderd
  3. Het implementeren van een LOD-systeem (Level of Detail) in uw toepassing, waardoor objecten ver weg worden weergegeven met een lagere polygone versie van dezelfde geometrie

Informatie over shaders in Unity

Een eenvoudige benadering om shaders in prestaties te vergelijken, is door het gemiddelde aantal bewerkingen te identificeren dat tijdens runtime wordt uitgevoerd. Dit kan eenvoudig worden gedaan in Unity.

  1. Selecteer uw shaderasset of selecteer een materiaal en selecteer vervolgens in de rechterbovenhoek van het controlevenster het tandwielpictogram gevolgd door 'Shader selecteren'

    Select shader in Unity

  2. Als de shader-asset is geselecteerd, selecteert u de knop Compileren en code weergeven onder het controlevenster

    Compile Shader Code in Unity

  3. Zoek na het compileren naar de sectie Statistieken in de resultaten met het aantal verschillende bewerkingen voor zowel het hoekpunt als de pixel shader (Opmerking: pixel shaders worden vaak ook wel fragment shaders genoemd)

    Unity Standard Shader Operations

Pixel-shaders optimaliseren

Als u de gecompileerde statistische resultaten bekijkt met behulp van de bovenstaande methode, voert de fragment-shader over het algemeen meer bewerkingen uit dan de hoekpunt-shader, gemiddeld. De fragment shader, ook wel de pixel-shader genoemd, wordt per pixel uitgevoerd op de schermuitvoer, terwijl de hoekpunt-shader alleen per hoekpunt wordt uitgevoerd van alle meshes die op het scherm worden getekend.

Fragment shaders hebben dus niet alleen meer instructies dan hoekpunt shaders vanwege alle belichtingsberekeningen, fragment shaders worden bijna altijd uitgevoerd op een grotere gegevensset. Als de schermuitvoer bijvoorbeeld een afbeelding van 2k bij 2k is, kan de fragment shader 2.000*2.000 = 4.000.000 keer worden uitgevoerd. Als twee ogen worden weergegeven, verdubbelt dit getal omdat er twee schermen zijn. Als een mixed reality-toepassing meerdere geslaagde, naverwerkingseffecten op volledig scherm heeft of meerdere meshes op dezelfde pixel weergeeft, neemt dit aantal aanzienlijk toe.

Daarom kan het verminderen van het aantal bewerkingen in de fragment shader over het algemeen veel grotere prestatieverbeteringen geven ten opzichte van optimalisaties in de hoekpunt-shader.

Alternatieven voor Unity Standard-shader

In plaats van een fysiek gebaseerde rendering (PBR) of een andere arcering van hoge kwaliteit te gebruiken, kijkt u naar het gebruik van een krachtigere en goedkopere shader. De Mixed Reality Toolkit biedt de MRTK-standaard shader die is geoptimaliseerd voor mixed reality-projecten.

Unity biedt ook een niet-verlicht, hoekpunt verlicht, diffuus en andere vereenvoudigde arceringsopties die sneller zijn vergeleken met de Unity Standard-shader. Zie Gebruik en prestaties van ingebouwde shaders voor meer gedetailleerde informatie.

Shader vooraf laden

Gebruik Shader-preloading en andere trucs om de laadtijd van shader te optimaliseren. Met name arcering vooraf laden betekent dat u geen treffers ziet vanwege runtime-shadercompilatie.

Overtekening beperken

In Unity kunt u overtekening weergeven voor hun scène door het menu Tekenmodus in de linkerbovenhoek van de scèneweergave te schakelen en Overdraw te selecteren.

Over het algemeen kan overdraw worden verzacht door objecten van tevoren te ruimen voordat ze naar de GPU worden verzonden. Unity biedt details over het implementeren van Occlusion Culling voor hun motor.

Aanbevelingen voor geheugen

Overmatige toewijzingstoewijzingsbewerkingen & kunnen nadelige gevolgen hebben voor uw holografische toepassing, wat resulteert in inconsistente prestaties, bevroren frames en ander schadelijk gedrag. Het is vooral belangrijk om geheugenoverwegingen te begrijpen bij het ontwikkelen in Unity, omdat geheugenbeheer wordt beheerd door de garbagecollector.

Garbagecollection

Holographic-apps verliezen de verwerkingstijd voor de garbagecollector (GC) wanneer de GC wordt geactiveerd om objecten te analyseren die niet langer binnen het bereik vallen tijdens de uitvoering en hun geheugen moet worden vrijgegeven, zodat deze beschikbaar kan worden gesteld voor hergebruik. Voor constante toewijzingen en de toewijzingen is over het algemeen vereist dat de garbagecollector vaker wordt uitgevoerd, waardoor de prestaties en gebruikerservaring pijn doen.

Unity biedt een uitstekende pagina die in detail uitlegt hoe de garbagecollector werkt en tips voor het schrijven van efficiëntere code met betrekking tot geheugenbeheer.

Een van de meest voorkomende procedures die tot overmatige garbagecollection leiden, is het niet in de cache opslaan van verwijzingen naar onderdelen en klassen in unity-ontwikkeling. Verwijzingen moeten worden vastgelegd tijdens Start() of Awake() en opnieuw worden gebruikt in latere functies, zoals Update() of LateUpdate().

Andere snelle tips:

  • De klasse StringBuilder C# gebruiken om tijdens runtime dynamisch complexe tekenreeksen te bouwen
  • Verwijder aanroepen naar Debug.Log() wanneer deze niet meer nodig zijn, omdat ze nog steeds worden uitgevoerd in alle buildversies van een app
  • Als uw holografische app over het algemeen veel geheugen vereist, kunt u System.GC.Collect() aanroepen tijdens het laden, zoals bij het presenteren van een laad- of overgangsscherm

Objectpooling

Objectpooling is een populaire techniek voor het verminderen van de kosten van continue objecttoewijzing en deallocaties. Dit wordt gedaan door een grote groep identieke objecten toe te wijzen en inactieve, beschikbare exemplaren uit deze pool te hergebruiken in plaats van voortdurend objecten in de loop van de tijd te verwijderen. Objectgroepen zijn ideaal voor hergebruikbare onderdelen die een variabele levensduur hebben tijdens een app.

Opstartprestaties

Overweeg om uw app te starten met een kleinere scène en vervolgens ScèneManager.LoadSceneAsync te gebruiken om de rest van de scène te laden. Hierdoor kan uw app zo snel mogelijk een interactieve status krijgen. Er kan een grote CPU-piek optreden terwijl de nieuwe scène wordt geactiveerd en dat alle gerenderde inhoud stoot of stoot. U kunt dit omzeilen door de eigenschap AsyncOperation.allowSceneActivation in te stellen op 'false' op de scène die wordt geladen, te wachten tot de scène is geladen, het scherm op zwart te wissen en deze vervolgens weer op 'true' in te stellen om de activering van de scène te voltooien.

Houd er rekening mee dat tijdens het laden van de opstartscène het holografische welkomstscherm wordt weergegeven aan de gebruiker.

Zie ook