Vision-Degree-Driven Loading Strategy for Real-Time Large-Scale Scene Rendering

Abstract

Large-scale scene rendering faces challenges in managing massive scene data and mitigating rendering latency caused by suboptimal loading sequences. Although current approaches utilize Level of Detail (LOD) for dynamic resource loading, two limitations remain. One is loading priority, which does not adequately consider the factors affecting visual effects such as LOD selection and visible area. The other is the insufficient trade-off between rendering quality and loading latency. To this end, we propose a loading prioritization metric called Vision Degree (VD), derived from LOD selection, loading time, and the trade-off between rendering quality and loading latency. During rendering, VDs are sorted in descending order to achieve an optimized loading and unloading sequence. At the same time, a compensation factor is proposed to further compensate for the visual loss caused by the reduced LOD level and to optimize the rendering effect. Finally, we optimize the initial viewpoint selection by minimizing the average model-to-viewpoint distance, thereby reducing the initial scene loading time. Experimental results demonstrate that our method reduces the rendering latency by 24–29% compared with the existing Area-of-Interest (AOI)-based loading strategy, while maintaining comparable visual quality.

1. Introduction

The rapid development of the metaverse and Smart City infrastructures has led to exponential growth in the demand for large-scale scene rendering. Nevertheless, the inherent limitations of hardware resources—particularly memory constraints—pose significant challenges, leading to reduced data processing efficiency and compromised rendering smoothness [1,2,3]. Currently, the solutions addressing these challenges rely on LOD and AOI-based dynamic loading strategies [4,5,6,7]. AOI is defined as a dynamically bounded spatial domain where computational resources are preferentially allocated based on viewport relevance. Loading strategies primarily consist of two categories: spatial partitioning-based approaches and semantic-driven approaches. The former typically employs AOI as the spatial demarcation criterion, confining scene tile loading to geometrically defined boundaries (e.g., circular or sector regions) around viewpoints; the latter employs semantic-augmented AOI partitioning integrated with object detection algorithms to identify key objects bearing high-priority semantic labels for optimized loading sequencing. However, existing prioritization schemes inadequately incorporate visual saliency factors, resulting in a compromised trade-off between quality and efficiency during large-scale scene rendering.

To address the trade-off between rendering quality and loading latency in large-scale scene rendering, this study proposes a loading priority metric called VD, which achieves adaptive data reduction and loading sequence optimization through a dual optimization mechanism. Within real-time rendering frameworks, VD incorporates a compensation factor to mitigate visual degradation caused by data reduction. Furthermore, we design an optimized initial viewpoint selection algorithm that minimizes initial loading latency using average model-to-viewpoint distances as the spatial relevance criteria. The experimental results demonstrate that the proposed method not only enhances scene loading smoothness, but also achieves an average improvement of 10 FPS in real-time frame rates compared to existing AOI-based approaches.

2. Related Works

2.1. Traditional LOD-Based Approaches

The core principle of LOD algorithms involves determining the Level of Detail for object rendering based on the spatial positions and the importance of model nodes within the scene. This approach reduces the detail level of non-critical objects, thereby conserving computational resources. Since the 21st century, with the rapid advancement of GPU technology, increasing research efforts have integrated LOD with GPU–CPU heterogeneous architectures, building upon the framework proposed by Asirvatham et al. [8], to achieve rapid simplification of large-scale scenes. In 2018, Lucas et al. [9] proposed a novel GPU architecture technique named visibility rendering order (VRO). For BIM models, Zhang et al. [10] developed a digital twin-based framework that extended existing LOD definitions of Building Information Models (BIMs). Sun et al. [11] introduced a redundancy removal method combining Principal Component Analysis (PCA) and Hausdorff-based comparison algorithms to identify standardized steel structure components, and proposed a Web3D lightweight visualization approach for redundant instances. Additionally, they established an LOD model loading mechanism based on mesh simplification algorithms to enhance the rendering efficiency.

2.2. Spatial Partitioning-Based Approaches

These methods typically establish resource loading priorities by evaluating spatial correlations (e.g., distance and visibility) between AOI sub-regions and the view frustum. Jia et al. [12] extended the traditional AOI to a Multi-Layered and Incrementally Scalable Sector of Interest (MISSOI), enabling efficient P2P transmission. However, its MISSOI partitioning algorithm needs to partition 2n layers of MISSOI on top of a single AOI layer, incurring high computational overhead in large-scale scenes rendering. For the real-time Web3D visualization of underground scenes, Liu et al. [13,14] proposed a lightweight scene management framework that enhances the online rendering efficiency of large-scale scenes through hierarchical preprocessing and dynamic loading strategies based on the Sector of Interest. This method provides targeted solutions for lightweight Web3D visualization of enclosed environments such as underground constructions and pipelines. For WebBIM data, Liu et al. [15,16] proposed the I-Frustum of Interest based on voxel rendering with a boundary shell. Smooth loading and unloading of the scene is achieved through a lightweight boundary shell and loading strategy based on the Interest Degree (ID). However, its scene applicability remains limited, as external production extraction relies on building shadow structures, resulting in restricted effectiveness for large-scale scenes. Su et al. [17] proposed a fast display method for a large-scale 3D city model based on the rule of viewpoint movement, where the appropriate LOD model was selected on the basis of the distance from the entity to the viewpoint and eccentricity. The operating efficiency was greatly improved, and the frame rate was increased by 50%. Li et al. [18] further proposed a cloud–edge–browser collaborative multi-granularity interest loading scheduling algorithm for large-scale scenes, and introduced ID based on AOI to further optimize the loading sequence of large-scale scenes.

2.3. Semantic-Driven Approaches

These methods determine resource loading priorities within AOI by integrating semantic labels (e.g., object categories and interaction priorities) with geometric metrics. Li et al. [19] proposed a user-interest-driven cloud–edge–browser collaborative architecture that predicts potential high-priority regions through user behavior history. Building upon prior research, Li et al. [20] developed a semantic-driven method for BIM scenes that preloads critical areas by predicting future AOI from user trajectories. However, the rendering framework lacks integration of lighting techniques, which may compromise visual quality in high-fidelity applications such as VR presentations. For urban scene location-based services (LBS), Lin et al. [21] pioneered the integration of deep reinforcement learning into semantically-guided AOI segmentation, employing Markov decision processes modeling to optimize AOI boundaries, thereby enabling intelligent LBS management.

3. Methods

The overall pipeline illustrated in Figure 1 comprises three modules: a locally optimal initial viewpoint selection module that achieves rapid initial viewpoint rendering through viewpoint selection algorithms; a dynamic loading module that determines model loading/unloading priorities via VD; and an AO compensation module integrating VD with a compensation factor to achieve AO effects optimization.

3.1. Vision Degree

Scene visual influence is quantified using three metrics: LOD level (LOD Degree, LD), loading latency (Transfer Degree, TD), and rendering area for loading latency (Vision Transfer Degree, VTD). These metrics form VD, which establishes quantitative criteria for model loading prioritization. The system maintains three core queues (update list, save list, delete list) dynamically prioritized by VD values), with parameters defined as follows:

Vision Degree (VD). VD is the weighted result of LD, TD and VTD which is defined as

$$VD=\alpha ·LD+\beta ·TD+\gamma ·VTD,$$

(1)

where $\alpha +\beta +\gamma =1$, $\alpha$, the weighting coefficients $\alpha$, $\beta$, and $\gamma$ correspond to distinct dimensions of $VD$, determined through experimental parameter tuning. Balancing rendering quality and loading overhead is critical for large-scale scenes. Scenes exhibiting higher ratios of rendering quality and loading latency are, therefore, prioritized, thus receiving higher $VD$ values. $VD$ also quantifies LOD degradation levels, with higher $VD$ values indicating milder LOD degradation. The initial parameters are set as $\alpha =0.2,\beta =0.2,\gamma =0.6$, with optimized configurations determined as $\alpha =0.2,\beta =0.3,\gamma =0.5$.

LOD Degree (LD). LD is defined as the normalized ratio between the current LOD level and total LOD hierarchy, expressed as:

$$LD\left(n_{target}\right)={\displaystyle \frac{LOD\left(n_{target}\right)}{LODSize}},$$

(2)

where $n_{target}$ denotes the currently selected model node, $LOD\left(n_{target}\right)$ represents the node’s current LOD hierarchy level, and $LODSize$ is the preset total LOD hierarchy count. $LD\left(n_{target}\right)$ quantifies the geometric detail level of scene LOD, where higher hierarchical values indicate finer geometric descriptions and lower LOD degradation.

Transfer Degree (TD). TD is defined as the ratio between the target model size and total model sizes within the current viewpoint, expressed as follows:

$$TD(n_{target},n_{viewpoint})={\displaystyle \frac{ModelV\left(n_{target}\right)}{ModelV\left(n_{viewpoint}\right)}},$$

(3)

where $n_{target}$ and $n_{viewpoint}$ denote the currently selected model node and its parent node, respectively. $ModelV\left(n_{target}\right)$ computes the geometric volume of the target model, and $ModelV\left(n_{viewpoint}\right)$ represents the geometric volume of the parent node model. $TD(n_{target},n_{viewpoint})$ quantifies the volumetric ratio of the target model relative to its parent node, where increased $ModelV\left(n_{target}\right)$ coupled with decreased $ModelV\left(n_{viewpoint}\right)$ enhances visual saliency, consequently elevating both the loading priority and VD value.

Vision Transfer Degree (VTD). VTD is defined as the composite metric comprising Area Degree (AD) and Space Degree (SD). AD is calculated as the ratio of the model’s projected screen area to the total screen space in the current viewpoint, while SD quantifies the ratio of the model’s volumetric occupancy to the 3D spatial extent of the current viewpoint. VTD is formulated as the ratio of AD to SD, expressed as follows:

$$VTD(n_{target},n_{viewpoint})={\displaystyle \frac{AD\left(n_{target}\right)}{SD(n_{target},n_{viewpoint})}},$$

(4)

where

$$\begin{array}{c}\hfill AD\left(n_{target}\right)={\displaystyle \frac{Area\left(n_{target}\right)}{ScreenArea}}\\ \hfill SD(n_{target},n_{viewpoint})={\displaystyle \frac{Volume\left(Box\left(n_{target}\right)\right)}{Volume\left(Box\left(n_{viewpoint}\right)\right)}},\end{array}$$

(5)

where $n_{target}$ and $n_{viewpoint}$ denote the currently selected model node and its parent node, respectively. $Volume\left(Box\left(n_{target}\right)\right)$ and $Volume\left(Box\left(n_{viewpoint}\right)\right)$ represent the volumes of the current model’s bounding box and its parent model’s bounding box. $Area\left(n_{target}\right)$ is the projected area of the model’s bounding box on the xoz-plane, while $ScreenArea$ refers to the total screen space area. $AD\left(n_{target}\right)$ quantifies the model’s display proportion in screen space, directly influencing user visual perception. $SD(n_{target},n_{viewpoint})$ characterizes the volumetric proportion of the current model relative to its parent model. $VTD(n_{target},n_{viewpoint})$ is defined as the ratio of $AD\left(n_{target}\right)$ to $SD(n_{target},n_{viewpoint})$, measuring the projection efficiency from 3D space to screen space. An increased $AD\left(n_{target}\right)$ combined with a decreased $SD(n_{target},n_{viewpoint})$ enhances projection efficiency, thereby elevating the loading priority.

3.2. VD-Based Loading Strategy

The system implements a VD-based loading strategy as illustrated in Figure 2. First, the dynamic loading priority manages the update list($L_u$), save list($L_s$), and delete list($L_d$). After applying viewpoint transformation matrix updates, the system generates the current visible model set $M_{vis}=m_i,\dots ,m_j$ and dynamically maintains the three core lists using the optimize algorithm based on VD. As detailed in Algorithm 1, $L_u$ is optimized using loading priority metric VD. LOD degradation is triggered when the LOD degradation count exceeds zero and the model VD falls below the average VD. As Figure 3 shows, scene loading follows descending VD order. VD also controls model unloading in $L_d$ under the constraint $\sum V{D}_{unloaded}\ge \sum V{D}_{loaded}$, prioritizing models with minimal distances from the models to the viewpoint.

Algorithm 1 Optimize update list based on VD

Require: Update list: $L_u$, average VD: $V{D}_a$, maximum number of updates: $MAXCOUNT$, minimum fine level: $MINLEVEL$

Ensure: Optimized update list: $L_u^{\prime }$

1: Number of updates: $count\Leftarrow 0$

2: Number not traversed: $travel\Leftarrow L_u.Length-1$

3: while  $travel\ge 0\&\&count<MAXCOUNT$  do

4:       $[VD,level,filename,flag,\dots ]\Leftarrow L_u\left[travel\right]$

5:       if $VD<V{D}_a$ then

6:             if $Level(VD,V{D}_a,level)\ge MINLEVEL$ then

7:                  if $level-Level(VD,V{D}_a,level)+count\le MAXCOUNT$ then

8:                  $count\Leftarrow level-Level(VD,V{D}_a,level)+count$

9:                  $level\Leftarrow Level(VD,V{D}_a,level)$

10:                  $travel\Leftarrow travel-1$

11:                  else

12:                  $level\Leftarrow level-MAXCOUNT+count$

13:                  $count\Leftarrow MAXCOUNT$

14:                  $travel\Leftarrow travel-1$

15:                  end if

16:             else

17:                  $travel\Leftarrow travel-1$

18:             end if

19:       end if

20: end while

3.3. Compensation Factor for AO Optimization

Urban scene visualization requires enhanced rendering quality for regions with high visual saliency. Building on Liu et al.’s visual attraction elements [22], we construct a compensation factor by the quantifying spatial distance parameter.

The spatial distance parameter D is quantified by the average distance between models and the viewpoint. D is defined as follows:

$$\begin{array}{c}\hfill Ds(n_{target},p)={\displaystyle \frac{{\sum }_i^N{∥Box\left(n_{target}\right).center-p∥}_2}{N}}\\ \hfill D(n_{target},p)={\displaystyle \frac{(MaxDistance+MinDistance)/2}{Ds(n_{target},p)}},\end{array}$$

(6)

where $Ds(n_{target},p)$ denotes the average distance between each model and the camera viewpoint in the scene. $MaxDistance$ and $MinDistance$ represent the maximum and minimum distances within the model list, respectively. $D(n_{target},p)$ is defined as the ratio of the normalized average distance to the actual average distance, quantifying the spatial enclosure of the scene relative to the user. A higher $D(n_{target},p)$ value indicates a denser model distribution within the viewpoint and broader AO coverage.

The compensation factor is determined by $D(n,p)$, which modulates the AO intensity and radius. The rendered results are presented in Section 4.

3.4. Local Optimal Initial Viewpoint Selection

Building on the optimal initial viewpoint selection algorithm proposed by Li et al. [18], our method workflow is illustrated in Figure 4, with the detailed steps outlined as follows:

• The bounding sphere of the scene is initially computed based on its geometric characteristics. An optimized bounding sphere is then generated by reducing the initial radius by 50%.
• Select the upper hemisphere on a surface ring ${10}^{\circ }$ to ${20}^{\circ }$ from the xoz plane.
• A range of ${20}^{\circ }$ is randomly selected as a window on the surface ring and subdivided evenly into discrete viewpoints.
• The optimized initial viewpoint selection algorithm employs the average distance from scene objects to the viewpoint as a spatial relevance metric, aiming to maximize scene coverage in the vicinity of the viewpoint.
• Based on the computed locally optimal initial viewpoint, the model list within the viewpoint is retrieved, and model LOD and loading priorities are dynamically adjusted according to VD.

4. Results

To validate the effectiveness of the proposed method, we measured the initial loading time, frame rate, AO effects, PSNR, and SSIM as the performance metrics. All scenes were evaluated on an experimental platform equipped with an Intel Core i5-12490F CPU, 16 GB RAM, and an NVIDIA GeForce RTX3070 GPU.

4.1. Test Scenes

The test scenes selected in this study are listed in

Table 1. Test scenes information.

Scene/Parameter	Size	Number of Triangles in lod0/L21
City A	63.5 GB	240 million
City B	10.7 GB	30 million

, with the visualizations of City A and City B presented in Figure 5a,b, respectively.

4.2. Test Results

4.2.1. Initial Loading Time

Two test routes were conducted in City A and City B, respectively. The initial loading time is defined as the duration from the user’s first scene load until the LOD levels cease to update.

Table 2. Initial loading time of different modes in each scene.

Mode/Scene	City A	City B
ID	107.4 s	91.0 s
ID with initial viewpoint selection	35.2 s	46.3 s
VD (Ours)	85.2 s	69.0 s
VD with initial viewpoint selection (Ours)	26.7 s	34.0 s

presents the initial loading time results under different loading strategies across scenes. Figure 6 provides a visual comparison of the initial loading process, while Figure 7 shows the visual comparison during roaming. The results demonstrate that VD-based loading strategy with an initial viewpoint selection achieves significant performance improvements. Compared to the ID-based method [18], VD strategy with initial viewpoint selection reduces the average loading time by 25.5% across scenes. Although the LOD of some models was reduced, their rendering quality remains comparable to the exiting AOI strategy. Each test route was applied with two distinct loading strategies, resulting in a total of four tests. For each test, 100 frames were sampled to compute the average PSNR and SSIM, with comparative results presented in

Table 3. Rendering performance metrics comparison.

Scene	PSNR	SSIM	FPS (Initial)	FPS (Viewpoint Section)	FPS (Roaming)
City A (ID)	34.391	0.870	4.62	23.41	19.10
City A (VD)	34.792	0.865	13.95	37.26	30.02
City B (ID)	34.806	0.863	11.12	22.43	20.91
City B (VD)	33.951	0.836	18.2	40.20	31.42

. From Figure 6 and Figure 7, it can be observed that the VD method performs better in mixed scenes containing buildings, roads, and trees, with a clearer expression of scene details.

4.2.2. Frame Rate

Two test routes were conducted in City A and City B, respectively. Frame rate is positively correlated with scene navigation smoothness. A higher frame rate enhances visual continuity during user interaction. Navigation loading latency is defined as the time interval between viewpoint updates and scene LOD updates reaching level 21 or ceasing. Prolonged latency intensifies visual lag effects, leading to reduced frame rates. In this study, navigation loading latency is quantified by the average frame rate during the loading phase. The average frame rates for both initial loading and navigation loading phases across multiple scenes are demonstrated in the Table 3. Figure 8 presents the frame rate variation during roaming in the test scenes. Experimental results indicate that the proposed loading strategy achieves an average frame rate exceeding 30. Figure 8 demonstrates that during roaming, the VD method outperforms the ID method in frame rate (achieving real-time rendering) with smoother loading performance. Notably, at the onset of viewpoint transition, frame rate temporarily spikes due to loading delay before gradually stabilizing.

4.2.3. Compensation Factor for AO Effects

An AO effect is a critical component of urban scene visualization. The rendering process is optimized through the joint application of VD and compensation factor to counteract quality degradation arising from LOD reductions. As shown in Figure 9, the upper part illustrates rendering results without VD and compensation factor, while the lower part presents the optimized results after applying these components. Experimental results demonstrate that implementing the compensation factor enhances visual effects by partially mitigating the perceptual degradation induced by LOD reduction.

5. Conclusions

This paper proposes a VD-based optimization strategy for large-scale scene loading and rendering. Building upon exiting AOI methods, the strategy addresses efficient loading and rendering efficiency in large-scale scenes by optimizing loading priorities via VD and reducing scene data. Visual saliency parameters are quantified to compensate for rendering detail loss. Additionally, an initial viewpoint selection algorithm prioritizing model density in the viewpoint vicinity is introduced, significantly reducing the initial loading time. The experimental results demonstrate that the proposed strategy outperforms existing AOI-based approaches in mitigating low fluency and low rendering efficiency for large-scale scene visualization.

However, there are still difficulties in this field, particularly regarding computational demands. While the proposed loading strategy demonstrates a promising performance in large-scale scenes, limitations emerge when handling ultra-scale scenes. Future research will prioritize hybrid computing architectures integrating edge frameworks to leverage the computational capabilities of edge devices, thereby enhancing computational efficiency through distributed processing paradigms.

Moreover, current compensation factor quantification methodology exhibits limitations in flexibility due to its partial incorporation of visual attraction elements. Future research directions will focus on transitioning from single-element optimization to multi-element joint optimization frameworks, thereby enabling adaptive visual enhancement in large-scale scenes through dynamic parameter coordination.