Guide de configuration des paramètres de performance de rendu

Aperçu

Pour s'adapter aux appareils de différents niveaux de performance, le LCC Unity SDK fournit plusieurs paramètres de configuration de performance de rendu. Ils sont répartis sur la classe LCCManager et la classe Renderer, impliquant principalement les méthodes suivantes :

Remarque :

Parmi les paramètres ci-dessus, les unités des méthodes liées au nombre de Splats (SetMaxBufferSplat, SetFullRenderSplat, SetMaxRenderSplats) sont toutes en dizaines de milliers, c'est-à-dire valeur transmise × 10000 = nombre réel de Splats.

Remarque :

SetMaxBufferSplat définit l'espace tampon maximal de mémoire CPU et de mémoire vidéo GPU disponible pour le rendu, tandis que SetMaxRenderSplats définit le nombre de primitives Splat rendues à l'écran pendant le rendu en streaming par blocs. Par conséquent, si la valeur définie par SetMaxRenderSplats dépasse la valeur définie par SetMaxBufferSplat, elle sera tronquée.

Modes de rendu du SDK

Pour s'adapter à diverses données et plateformes, le SDK possède 3 modes de rendu principaux. Comprendre les modes de rendu est le prérequis pour définir correctement les paramètres de performance, car différents paramètres ne prennent effet que dans des modes spécifiques.

• Mode SingleRender (par défaut) : principalement utilisé sur PC/Mac. Ce mode ne permet pas de créer plusieurs Renderers, ce qui signifie qu'une seule scène LCC peut être rendue à la fois. Lorsque le volume de données est petit et répond aux exigences, les données seront entièrement rendues (les données LOD0 complètes sont chargées, sans bascule LOD dynamique, meilleure qualité de rendu) ; lorsque les primitives Splat LOD0 dépassent la quantité totale pouvant être entièrement rendue, les données seront rendues par blocs, en utilisant un mécanisme de rendu en streaming LOD dynamique à l'exécution pour s'adapter au rendu de très grandes scènes.
• Mode MultiRender : principalement utilisé sur PC/Mac. Ce mode permet le rendu mixte en temps réel de plusieurs scènes LCC ; toutes les données de scène seront rendues par blocs en utilisant le mécanisme LOD dynamique.
• Chemin de rendu par blocs : sur les plateformes Mobile (iOS / Android), VR (Pico 4 / Quest 3), ainsi que les sources de données HTTP sur PC/Mac, le chemin de rendu par blocs est utilisé, employant le mécanisme LOD dynamique.

Relation entre les trois modes de rendu du SDK et les chemins de rendu complet / par blocs

Rendu complet vs rendu par blocs :

• Rendu complet : charge et rend les données LOD0 complètes en une fois, meilleure qualité d'image, uniquement activé en mode SingleRender PC/Mac lorsque le volume de données LOD0 remplit les conditions.
• Rendu par blocs : charge dynamiquement les données de niveau LOD selon le frustum de la caméra de rendu, contrôle le nombre de Splats à l'écran et s'adapte aux environnements matériels à mémoire vidéo et performances limitées.

Valeurs par défaut du SDK

Les valeurs par défaut, les valeurs minimales autorisées et les valeurs maximales autorisées pour chaque plateforme sont les suivantes (unité : dizaines de milliers) :

Stratégie de configuration PC/Mac

Pour PC/Mac, il est recommandé de configurer les paramètres selon les niveaux de qualité suivants (unité de nombre de Splats : dizaines de milliers) :

Remarques sur le basculement de niveau à l'exécution

• Lors du basculement entre les niveaux Moyen / Élevé / Très élevé, vous pouvez laisser le Buffer global inchangé, et la logique de gestion est très simple : vous n'avez besoin que de définir le seuil de rendu complet, le nombre de rendus à l'écran et StartLOD.
• Lors du basculement entre les niveaux Très bas / Bas et les autres niveaux, la situation est plus complexe : comme le Buffer global peut déjà être alloué, vous devez d'abord détruire le Buffer global d'origine puis créer un nouveau Buffer. Cette opération nécessite de disposer de tous les Renderers avec Dispose() et de libérer le Buffer, puis de réacquérir le Renderer via GetRender().
• Recommandation actuelle : définissez le niveau par défaut sur Élevé ; lors du basculement de niveau, laissez le Buffer global inchangé, mais gérez tout de même le basculement rendu complet/par blocs.

Remarques

1. SetMaxBufferSplat() doit être défini tout au début, idéalement avant GetRender(). Si vous définissez cette valeur après que la scène est déjà en cours d'exécution, vous devez disposer de tous les Renderers avec Dispose() puis réacquérir le Renderer pour qu'elle prenne effet.
2. SetFullRenderSplat() n'est efficace que pour le mode SingleRender PC/Mac et doit être défini avant Load().
3. SetMaxRenderSplats() s'applique à tout le rendu par blocs et peut être défini à tout moment, mais doit être postérieur à SetMaxBufferSplat() (si cette méthode est appelée).

API de performance de rendu

SetMaxBufferSplat

// Valeur de retour : void
public void SetMaxBufferSplat(int _count)

Définit la capacité maximale du Buffer GPU (nombre de Splats). Dans le chemin RenderCore (bloc MultiRender / SingleRender), il détermine la taille du Buffer global partagé ; en mode SingleRender Full Load, il est alloué selon le volume de données réel et ne référence pas cette valeur. Alloué une fois et ne peut pas être modifié dynamiquement.

Exemple d'utilisation :

lccManager.SetMaxBufferSplat(3000); // 30 millions de points (défaut PC/Mac)
lccManager.SetMaxBufferSplat(4450); // 44,5 millions de points (maximum PC/Mac)

Description :

• L'unité est « dizaines de milliers » ; valeur transmise × 10000 = nombre réel de Splats.
• Doit être appelé avant tout Renderer.Load(), sinon il retourne une erreur.
• Doit d'abord appeler SetPlatformType.
• Plus la capacité est grande, plus l'utilisation de la mémoire vidéo est élevée ; définissez selon les besoins.
• Limites de plateforme : PC/Mac 44,5 millions, Android/iOS 6 millions, VR 2 millions ; minimum 1 million.
• Valeurs par défaut : PC/Mac 30 millions, Android/iOS 3 millions, VR 1 million.

SetFullRenderSplat

// Valeur de retour : void
public void SetFullRenderSplat(int _count)

Définit le seuil de nombre de Splats entre le rendu complet et le rendu par blocs en mode SingleRender PC/Mac. Lorsque le nombre de Splats LOD0 des données est inférieur à cette valeur, le chemin de rendu complet est utilisé (Buffer GPU dédié) ; sinon le chemin de rendu par blocs est utilisé.

Exemple d'utilisation :

lccManager.SetFullRenderSplat(2500); // 25 millions de points

Description :

• L'unité est « dizaines de milliers ».
• Pris en charge uniquement sur les plateformes PC/Mac ; l'appeler sur d'autres plateformes retourne une erreur directement.
• Doit être appelé avant tout Renderer.Load().
• Doit d'abord appeler SetPlatformType.
• Plage de valeurs [100, 4450] (c'est-à-dire 1 million ~ 44,5 millions).

SetMaxRenderSplats

// Valeur de retour : void
public void SetMaxRenderSplats(int _count)

Définit le nombre maximal de Splats rendus à l'écran par image en rendu par blocs. Peut être appelé dynamiquement après Load(), et est borné par la limite supérieure définie par SetMaxBufferSplat. L'appeler en mode de rendu complet SingleRender n'a aucun effet (journalise un avertissement et retourne directement).

Exemple d'utilisation :

lccManager.SetMaxRenderSplats(2000); // 20 millions de points

Description :

• L'unité est « dizaines de milliers » ; valeur transmise × 10000 = nombre réel de Splats.
• Peut être ajusté dynamiquement à l'exécution.
• Ne doit pas dépasser la limite supérieure de capacité définie par SetMaxBufferSplat (s'il est dépassé, il est automatiquement borné et journalise un avertissement).
• L'ajustement à l'exécution n'est pas pris en charge en mode de rendu complet SingleRender.

SetStartLod

// Valeur de retour : void
public void SetStartLod(int lod)

Définit le point de départ de l'expansion LOD (basé sur 0). 0 signifie le plus fin ; plus le nombre est grand, plus le niveau est grossier. Cette méthode prend effet à l'exécution et doit être appelée après Load().

Exemple d'utilisation :

lccManager.SetStartLod(0);

Description :

• Uniquement efficace pour le rendu par blocs, plage [0, 10], automatiquement borné en cas de dépassement.
• La limite supérieure effective réelle est restreinte par le totalLevels des données.
• Le SDK prend effet immédiatement après l'appel.

SetDetailLevel

// Valeur de retour : void
public void SetDetailLevel(float sse)

Définit le niveau de détail de rendu, utilisé pour affiner la précision de rendu. Plus la valeur est grande, plus le rendu est fin et plus le coût de performance est élevé.

Exemple d'utilisation :

lccManager.SetDetailLevel(50f); // Précision moyenne

Description :

• Ce paramètre est utilisé pour affiner le détail de la scène, ne s'applique qu'au rendu par blocs, défaut 40, plage [1, 100], automatiquement borné en cas de dépassement.
• Utilise une correspondance logarithmique : la plage de valeurs basses est sensible aux changements, et la plage de valeurs hautes change doucement.
• Peut être ajusté dynamiquement à l'exécution.

SetRenderAll

// Valeur de retour : void
public void SetRenderAll(bool _renderAll)

Une méthode de la classe Renderer. Définit si ce Renderer force le rendu complet, et doit être appelée avant Load(). Utilisée uniquement pour le mode SingleRender PC/Mac : à l'exécution, elle compare le volume de données LOD0 à la limite supérieure de 44,5 millions ; si LOD0 < 44,5 millions, les données complètes LOD0 sont directement utilisées pour le rendu ; si LOD0 > 44,5 millions, ce réglage est inefficace (limité par le GBuffer maximal de Unity) et le rendu par blocs est utilisé à la place.

Exemple d'utilisation :

renderer.SetRenderAll(true);
renderer.Load(filePath, null, () => Debug.Log("Chargement complet"));

Description :

• Pris en charge uniquement sur les plateformes PC/Mac ; l'appeler sur mobile / VR journalise un avertissement et retourne.
• Le réglage prend effet au prochain appel Load() et n'affecte pas le jeu de données actuellement chargé.
• Peut être utilisé avec la propriété IsRenderAll pour interroger l'état actuel.