Real-Time Rendering of Continuous Levels of Detail forSparse Voxel Octrees

Szymon JabłonskiInstitute of Computer Science

Warsaw University of Technologyul. Nowowiejska 15/1900-665 Warsaw, Polands.jablonski@ii.pw.edu.pl

Tomasz MartynInstitute of Computer Science

Warsaw University of Technologyul. Nowowiejska 15/1900-665 Warsaw, Poland

martyn@ii.pw.edu.pl

ABSTRACTIn this paper, we present a novel approach to real-time, continuous and symmetrical level of detail (LOD) man-agement of a 3D object represented by a sparse voxel octree (SVO). We propose a new method for continuousand symmetrical transition between two detail levels. The method is based on a SVO representation extended byredundant, helper nodes which are used to achieve a proper interpolation of geometry and material data. We extendredundant nodes with a transition direction attribute. Additional memory requirements are minimized by storingindices in a direction vector lookup table in object space. The new method is applied for an accurate evaluation ofthe required LOD. It uses an image-based evaluation function, i.e. the standard level transition function based oncamera distance is extended by the real-time calculation of the current LOD pixel fill rate. We extend typical leveltransition function based on distance with real-time calculation of the current LOD pixel fill rate. Two differentimage based methods of SVO node pixel fill rate calculations using compute shaders or GPU queries and parallelreduce are presented. The developed LOD management algorithm is applicable for a raytracing and a rasterization-based rendering pipeline. The LOD transition algorithm allows to perform a dynamic and continues control of theSVO based objects which have not been available in other works. Moreover, the proposed fading algorithm basedon the fade out direction and scaling allows for a LOD change without any graphical artifacts or loss of the virtualscene immersion.

KeywordsComputer graphics, level of detail, sparse voxel octree, voxel rendering, parallel reduce, image processing

1 INTRODUCTIONComputer graphic engines are perfect examples of thesoft real-time systems [Tanen07]. A key requirementfor the real-time system is the processing time mea-sured in tenths of seconds or shorter. Interactive graphicapplications, such as computer games or virtual reality,require that all necessary logic computation and ren-dering is performed within a few milliseconds. Dueto the limited memory of GPUs, achieving satisfactoryrendering results requires an implementation of severaloptimization methods in our graphics engine pipeline.

An important observation is that with the perspectiveprojection objects that are far away from observer ap-pear on the screen much smaller than objects that are

Permission to make digital or hard copies of all or part ofthis work for personal or classroom use is granted withoutfee provided that copies are not made or distributed for profitor commercial advantage and that copies bear this notice andthe full citation on the first page. To copy otherwise, or re-publish, to post on servers or to redistribute to lists, requiresprior specific permission and/or a fee.

near the observer. This implies that they can be ren-dered with less geometrical or material details. Thus,different techniques for controlling the object’s currentlevel of detail (LOD) have been developed to adapt theobject’s complexity to their importance within the vir-tual scene.The LOD is one of the oldest problems in computergraphics. It was first presented in an article by JamesH. Clark in 1976 [Clark90] and was defined as the com-plexity of the 3D object located at a suitable distancefrom the observer. The main aim of using LOD controlalgorithms is to increase rendering efficiency by min-imizing the data consumption, e.g. a number of poly-gons or voxels. Increasing computation power of to-day’s GPUs allowed game developers to create highlydetailed virtual scenes represented by millions of poly-gons. As a consequence, efficient LOD managementalgorithms are needed more than ever.The tendency in recent years has been to improve thefeatures of continuous LOD algorithms by using thepossibilities offered by the graphics hardware, such asthe tessellation shaders [Schaf14]. The main prob-lem with these methods is that there are no special-

ized shaders to decimate geometry on GPU. Moreover,there is still the need to store a complex geometry inthe VRAM. As a result, the most commonly used so-lution in today’s graphics engines is to prepare sev-eral objects with different LODs and change them inreal-time based on their importance within the virtualscene [Lueb02].

In this paper, we present a novel approach to real-time,continuous and symmetrical management of a 3D ob-ject LOD represented by the sparse voxel octree (SVO).

2 RELATED WORKThere is a wide selection of literature on performing theLOD evaluation and control algorithms. Over the years,many methods of geometry simplification and continu-ous LOD controlling have been developed. However,most of them are actually using polygonal representa-tion of geometry and are connected to the LOD of vir-tual scene terrains based on height fields. We will focuson the papers that are most directly related to our work.

As we mentioned in the introduction, the most com-monly used method is based on preparing a finite countof objects in different LODs by artists and change thecurrently used one based on the specified distance func-tion [Lueb02]. It is very easy to implement and controlin real-time. However, the objects representing a differ-ent LOD have to be stored in GPU memory. Alterna-tively, a streaming functionality must be implementedin the graphic engine. Moreover, the continuous transi-tion between triangle based objects with a significantlydifferent number of polygons is quite difficult.

Schoeder et al. introduced algorithms to decimatea triangle mesh [Schroeder92]. Rossignac and Bor-rel extended their approach by developing vertexclustering method that uses the bounding box ofthe source mesh divided into the grid with all ofthe vertices in a given cell replaced with a singlevertex [Rossignac93]. Other groups of algorithms usean iterative approach based on primitive simplificationoperators [Lueb02] such as edge collapse or vertexremoval. One of the commonly applied iterative deci-mation technique is the QSlim algorithm [Garland97].In this method the pair collapse operator is iterativelyreplacing two vertices with one, causing neighboringfaces to become degenerated. However, the meshsimplification has been traditionally viewed as anon-interactive process not readily amenable to theGPU acceleration. Using the modern programmableGPU, many algorithms have been extended anddeveloped on the GPU. Ramos et al. developed amethod of continuous geometry complexity controllingbased on GPU triangle strip operations [Ramos06].The vertex clustering method has been extended byusing geometry shaders and a general-purpose datastructure called the probabilistic octree. It enabled

a simultaneous construction of multiple LODs andout-of-core simplification of extremely large polygonalmeshes [DeCoro07, Schiffner15, Willmott11].

Modern GPUs offer functionality to increase geome-try complexity in real-time [Schaf14]. By using pro-grammable tessellation shaders, we can increase thenumber of mesh triangles by dividing triangle patches.It is possible to achieve full control of how the objectgeometry is dived and to calculate all required data at-tributes such as normal vector and texture coordinates.This method has been effectively used in case of ter-rain rendering based on height field [Ripol12]. Even byusing low-resolution height map one can create highlydetailed terrain with continuous, distance dependentLOD. Using tessellation shaders one can increase thecomplexity of the processing object exclusively on theselected areas. Unfortunately, today’s graphics adaptersdo not offer any programmable shaders to decrease thecomplexity of processing object. In order to create asymmetrical method to increase and decrease objectLOD, it is necessary to combine simplification and tes-sellation approach into one algorithm.

Although all of the presented methods propose interest-ing ideas related to the LOD management, none of themis able to provide a symmetrical, continuous and univer-sal LOD control. A common feature of all of the pre-sented methods is the polygonal representation of 3Dobjects. The polygonal representation does not provideany hierarchical information. A solution to that prob-lem is the usage of the voxel representation. The SVOis the current standard method for representing and ren-dering voxels [Laine10, Bau11, Wil13]. Cyril Crassinwas able to perform visualization of global illuminationbased on an SVO and voxel cone tracing [Crassin11].The SVO is a hierarchical structure that, in additionto the significant voxel memory compression, offersobject’s LODs. Based on the voxelization resolutionone can calculate the maximum tree depth which is thenumber of the object’s LODs. A dynamic LOD is quiteoften mentioned in various articles. However, no onehas ever described an algorithm showing how to changethe current LOD and how to perform a transition be-tween the levels in a continuous way.

3 LOD MANAGEMENT ALGORITHMThis section describes the fundamental features of LODmanagement algorithms. All algorithms can be dividedinto the two main components:

• LOD evaluation — in this part one needs to deter-mine when to change the object’s current LOD. Theinitiation of the change and its direction depends on,for example, the distance between the object and theobserver or object size on the screen.

• LOD transition — this part of the algorithm dealswith the way of how the current LOD is changing. Inthe discrete model algorithm, the change is realizedby simple swapping of the object geometry or mate-rial data. In the case of the continuous algorithm inorder to achieve proper object transition, one needsto implement the interpolation between two selectedLODs.

The features of the developed algorithm are as follows:

• The 3D object is represented by an SVO.• The LOD management algorithm is independent of

the rendering method. It can be used with boththe ray tracing approach and the voxel visualizationachieved with the triangle rasterization pipeline.

• Helper data needed for the algorithm execution areminimized. In the case of ray tracing visualization,all necessary data can be calculated on the fly.

• The LOD transition is done smoothly using interpo-lation between two levels of SVO.

• The object geometry and material data LODs are in-creasing or decreasing symmetrically.

4 LOD EVALUATIONThe most commonly used measurement to evaluate theobject’s current LOD is the distance between the objectand the observer position. However, to do that, thescene designer must manually find the proper distancefor each object to achieve satisfying results. Thealgorithm proposed in this paper estimates the distanceusing a newly developed image-based method utilizingthe object rendering results achieved in pre-processingstage or by using rendering results of the previousframe.

4.1 Continuous evaluation functionIn general, the LOD evaluation function can be ex-pressed as:

y = f (x) (1)

where:

y = object LODx = evaluation parameter

Based on the computed distance between the object andobserver position the current LOD is determined in away presented in Fig. 1. For simplicity, the linear de-pendence between the distance value and the LOD isassumed.In this case Eq. 1 can be written in the following form:

y = max(

0,min(N− distx

,N))

(2)

where:

Figure 1: Linearly changing object LOD based on thedistance.

y = object LODN = number of object LODsdist = distance between object and observerx = defined distance offset between adjacent LODs

The computation results must be clamped to <0,N> inorder to operate only on the existing object LODs. As-suming N = 4, x = 2.0 and dist = 2.5 we get:

y = max(

0,min(4− 2.52.0

,4))= 2.75 (3)

Using mathematical round or truncate for the obtainedresult, we gain an integer value which represents thediscrete LOD index. In addition, the floating resultgives the possibility to control the continuous transitionweight between two LODs.The evaluation function presented above is based on thelinear dependence between the distance value and theLOD. However, this approach can hardly give satisfy-ing results on the virtual scene viewed with the perspec-tive projection. More accurate results could be achievedusing exponential or power functions.The biggest problem with distance based evaluationfunctions is that there is no exact relationship betweenthe distance and the resulting image. The renderingresult will be different, but there are no algorithmictools to describe scene complexity changes. In the nextsection, we propose a LOD evaluation method consid-ering the image pixels as the main information car-rier [Shannon48].

4.2 Pixel fill rate based evaluation func-tion

Using compute shaders, data obtained from the render-ing pass or GPU query objects according to the visual-ization algorithm, we can calculate how many pixels arefilled by the draw operation [Wright10]. Thus, we cancalculate how many pixels will be filled by some partof the object. The question is when we actually wantto change the current LOD. If the object is so far awayfrom the observer that there is no need to render it withthe current LOD because we won’t see any differencesin rendering results, we can optimize the rendering pro-cess by decreasing the current LOD. Similarly, whenthe object is close enough to be rendered with a morecomplex geometry or material details we increase thecurrent LOD.

5 PATTERN NODE SELECTIONMETHOD

In order to decide if the object is rendered with enoughdetails, we analyze the rendering results of the smallestpart of the object, the SVO node nearest to the observerposition. In this paper, we define this special node as apattern node. In order to find the pattern node, we pro-pose two methods which differ in calculation precisionand computing performance.

5.1 Approximate pattern node selectionThe first method is based on a simple and naive approxi-mation. For simplicity, we assume that the pattern nodeis exactly in the object bounding volume center posi-tion (even if actually there is no node in the selected 3Dspace). We can consider this method as an extension ofthe distance based evaluation method.

Having the object bounding volume and the node sizeof the current LOD, we render a single node off-screen.If our rendering pipeline is based on the ray tracing ap-proach, we simply render the root node of the objectscaled to the size of the current LOD node. In order tooptimize the additional ray tracing step, we can performray tracing to a smaller render target than screen size.The minimum size of the target viewport can be easilycalculated based on the object bounding volume and thecamera matrices. Using, for example, atomic counters,we can calculate how many pixels will be filled by thedraw operation. In the case of using a polygonal repre-sentation of the object, the same results can be achievedusing GPU query objects.

As we mentioned before, it is a naive approach but cangive satisfying results, especially on a low-power targetlike mobile devices.

5.2 Accurate pattern node selectionThe accurate approach is much more advanced than theprevious one. We want to find which SVO node ofthe object is the biggest on the screen. In other words,which one fills the most pixels of the resulting image.We must find the node in the current level of the SVOthat is the closest to the observer position. We cancalculate it on CPU by performing a simple softwarerenderer but it is a computationally expensive solutionhardly executable in real-time.

In order to obtain an accurate result, we need to per-form the additional rendering and computation pass be-fore the SVO visualization step. The accurate selectionmethod will depend on the rendering algorithm. In thissection we describe the pattern node selection for theray tracing approach as well as for the triangle-basedrasterization pipeline.

The foundation of the accurate pattern node selectionalgorithm is finding an SVO node with the smallest

depth value for the current viewpoint. It means that be-fore performing the final rendering, we need to find thenode and count have many pixels will be filled by thenode. The proposed solution can be implemented in avarious way. In our work, we decided to use computeshaders. However, the developed solution can be im-plemented in other GPGPU interfaces such as CUDAor OpenCL.

5.2.1 Depth and node id texture generationWe propose an image based solution to find the patternnode utilizing the node depth information. By using thedepth buffer, we find which pixel of the resulting imagebelongs to the object closest to the observer. The firststep of our algorithm is an off-screen z-pass rendering.We use single channel render target texture with e.g.R32F or R16F internal format and save the linearizeddepth information. Further, the depth information hasto be correlated to the SVO nodes.

The first step of our method requires defining unique idsfor all SVO nodes. To optimize the node finding opera-tion with a specified index it is recommended to createa lookup table for the tree nodes. Then, we extend thefirst pass of the algorithm by the saving node indicesto the second texture channel. With the depth-only so-lution we could use floating point textures but unfortu-nately, we cannot save and retrieve integer or unsignedinteger data from a float texture without data loss. Ahigh-resolution voxel object will have ids counted inmillions and we could lose the information. To solvethis problem we use the unsigned integer type texture.Moreover, when saving the linearized depth informa-tion we perform normalization to the defined data rangeby multiplying depth values. We use a texture in theRG32UI internal format.

5.2.2 Minimum depth node seekingThe next step of our algorithm is to find the minimumdepth from the rendered texture. If we need this infor-mation on CPU, we could transfer the texture data fromGPU memory into the RAM. Due to the high cost ofthis data transfer, we might not be able to evaluate theLOD in real-time. In order to achieve real-time results,we can use two different solutions.

First of them is based on the parallel reduce algorithmon GPU [Buck04]. Using a compute shader, we createa new texture with half size of the source texture. Then,using a simple code we seek for the smallest depth valueof N neighbors and store it in the new texture. By thedefined number of iterations, we create a small texturewith candidate nodes. We perform the parallel reducealgorithm until we create a 1x1 resolution texture andtransfer it or read it on CPU. It is also possible to stopthe iteration when our texture is small enough for be-ing transferred to the CPU efficiently. In our imple-mentation, we used the 1280x720 render target and 4

iterations of the parallel reduce algorithm resulting in a80x45 resolution texture. We iterate through and findthe pattern node on the CPU.

With the parallel reduce algorithm we can efficientlyfind the pattern node but we recommend an alternativesolution. When performing the rendering operation, wecan save the minimum depth of the rendered nodes withthe corresponding node id by using the atomic opera-tions and shader storage buffer objects. Thanks to that,we can use this information in the next step of our al-gorithm. Additionally, the access to the data stored inthe shader storage buffer object on CPU side is very ef-ficient. With a compute shader, we calculate how manypixels are filled by the found SVO node. This opera-tion is performed in the same way for the ray tracingrendering approach and triangle based rasterization.

5.2.3 Optimizations and restrictionsThe proposed solution requires an additional render-ing step for finding the accurate pattern node. In somecases, this might be too expensive in order to fit the de-fined time requirements. We must render the 3D objectstwice. In order to optimize our algorithm, we can usethe previously rendered frame. In that case, apart fromrendering the final image, we need to save the depthand voxel id data to an additional render target. Afterthat, using the obtained minimum depth value and thenode id stored in the shader storage buffer object, wecan calculate the fill rate value by means of a computeshader.

The described algorithms give us the accurate resultsonly when all voxels of a 3D object have exactly thesame size. Otherwise, it is necessary to perform anadditional calculation to obtain the proper patternvoxel. In order to obtain the correct interpolationweight, which will be used in the LOD transition stage,we must take into account the render target resolution.

5.3 Function boundary conditionsLast but not least an important part of the LOD evalu-ation algorithm is the boundary conditions of the LODevaluation function. The defined evaluation boundariesare as follows:

• Minimum condition — defines the object mini-mum LOD. If the rendering of some object on thevirtual screen produces N pixels corresponding tothe minimum condition, there is no need to executethe evaluation and transition algorithm. This is theuniversal minimum boundary condition that is beused for any kind of voxel visualization algorithm.We defined N as a parameter, but the perfect func-tion should use N defined as 1.

• Maximum condition — defines the object maxi-mum LOD based on the position on the scene in

relation to the observer. This boundary is very im-portant because it defines when to stop the executionof the LOD evaluation function. It represents the sit-uation when the object is rendered with the highestpossible complexity. The maximum boundary con-dition is reached when exactly one voxel of the ob-ject corresponds to exactly one pixel of the resultingimage. We can check this condition by comparingthe filled pixel number with the voxel number usedto render the image. The atomic counter can be usedto calculate how many times a SVO node was ren-dered on the screen. After that, the sum of all usedSVO nodes can be calculated.

6 PATTERN NODE BASED EVALUA-TION FUNCTION

The object’s current LOD can be found using the pat-tern node pixel fill rate as an argument for the levelevaluation function. The proposed evaluation methodis based on the extended distance based function pre-sented in section 4.1. The main difference is the usageof the pixel fill rate instead of the distance as the eval-uation function parameter. Another very important dif-ference is the type of the propagation function. The dis-tance based approach discussed earlier assumed a lineardependence on the distance. In the case of objects thatare represented by the SVO, an object rendered withthe N-th LOD fills about four times more pixels thanthe same object rendered with the N-1-th level. Basedon this fact we propose the LOD evaluation functiondescribed by Eq. 4 and 5.

y = max(

0.0,min(f illRate

N−LOD∑

i=0maxRate∗ x

,1.0))

(4)

y =

< minRate⇒ decrease level1.0⇒ increase level

(0.0,1.0)⇒ interpolate levels(5)

where:

y = LOD interpolation weightf illRate = pattern node pixel fill rateN = number of object LODsLOD = object current LODx = defined geometric progression valuemaxRate = defined max fill rateminRate = defined min fill rate

An additional step, which is not necessary with thedistance-based approach is the calibration of the ob-ject’s LOD. Before scene rendering, we must calculatethe current LOD for all SVO based objects. In order todo that we use the following algorithm:

1. Find the pattern nodes for all LODs.2. Calculate the pixel fill rate for all found pattern

nodes.3. Find the minimum fill rate value. Neglect values

lower than the specified value or equal to zero.4. Set the object’s current LOD to the level with the

minimum fill rate value.

As in the case of using the distance-based evaluationfunction, our algorithm requires the user input for theminimum and maximum fill rate for each object LODsdefined with geometric progression.

For rendering results presented in section 8 we used thefollowing parameters: maxRate = 16 pixels, minRate =1 pixels and x = 1.

7 LOD TRANSITIONThe core stage of the LOD management algorithm is theimplementation of the current level transition method.The most straightforward solution to change the currentLOD is to just stop the ray tracing algorithm at a speci-fied level acquired from the evaluation pass. In the caseof using triangle meshes, change object’s vertex databuffers and materials. However, it may produce visiblemodel swapping artifacts that adversely affect the per-ception and immersion of the virtual scene. Thanks tothe voxel representation, the proposed algorithm is freefrom the limitations imposed by the polygons graphicrepresentation.

The LOD control algorithm aims to change two at-tributes of the 3D object — geometry and material. Inthe voxel representation, both these attributes are re-lated. With the SVO structure, each node can be di-vided into the maximum eight new nodes with differentattribute values. When changing to a higher LOD, somechild nodes may disappear creating changes in the ob-ject’s geometry. Other nodes will just change the valuesof their attributes. A similar situation exists when theLOD decreases. Fig. 2 shows how the object geometryand material complexity changes between three LODs.

We can observe that if some node has a full set of chil-drens it is quite easy to perform the data interpolationbetween the parent node and child nodes. For example,using linear interpolation. The problem arises whensome potential child node is missing, or when a parenthas only one child. In order to accomplish the properlevel transition, it is necessary to solve these issues. Be-low we describe the proposed algorithm for the SVObased object geometry and material transitions.

7.1 Object material transitionThe new type of an SVO node is introduced. We callit redundant node based on its actual meaning for theobject representation. The redundant node can be the

Figure 2: Object differences between three levels ofStanford Bunny [Stanford11].

actual part of the SVO, or it is just an information aboutthe additional node in the tree. If the last traversingnode has not the full set of children - we fulfill the gapswith the redundant nodes. We treat the last traversinglevel of the tree as it has a full set of child’s. The mainidea behind the redundant node is that in order to per-form the interpolation between the parent and the childnodes the number of nodes at both levels must be thesame. This is necessary for a continuous transition fromone level to another.

All interpolation operations are performed between theparent and child node. Let’s start with the parent noderepresentation. As we mentioned before, each nodecan be divided into maximum eight child nodes. Thismeans that we can treat the parent node as eight identi-cal nodes with the same attributes. The more complexissue is with the children nodes. If the current nodedoes not have eight children we must replace the miss-ing nodes with the redundant nodes. Such nodes willhave identical attributes as the parent node. Thanks tothat, on both tree levels we will have an identical num-ber of nodes. Fig. 3 presents the idea of using redun-

dant nodes for the two-dimensional grid. For a 3D datastructure like the SVO, the method is identical.

Figure 3: The idea of the dividing a parent node to eightidentical nodes with redundant child nodes. Dividedparent nodes and redundant nodes are highlighted withstripped lines.

7.2 Object geometry transitionUsing the parent node division with the redundantchild nodes we achieved the possibility to performthe data interpolation between two LODs. However,the redundant nodes must somehow disappear at theend of the level transition. The most straightforwardway to achieve this is by using alpha blending withtransparency. Unfortunately, this solution affects othernodes and create unacceptable artifacts.

We propose an alternative solution based on scaling theredundant nodes. Parallel to the data interpolation, withthe interpolation weight parameter we change the sizeof the redundant nodes from the initial values to zero.However, the scale transformation in the defined origincauses the formation of holes at the edges of the objects.Thus, there is the need for an additional redundant nodeposition control, so that they will be absorbed by thenearest neighbor and disappear in a more natural way.

In order to implement redundant nodes fading out weneed to find the node’s nearest neighbor and calculatethe fading direction. The SVO structure guarantees thateach node has a connected neighbor. If we cannot findany candidates on the children level, we seek for it atthe parent level. The only exception to this rule is thetree root node. The direction vector for the root nodewill never be required. In the case of the ray tracingapproach, we have access to the neighbor nodes dur-ing object rendering. If we do not have an access tothe neighbor nodes during object rendering, we needto store pre-calculated values in an additional node at-tribute. Fortunately, we have a finite number of possi-ble directions. A node can have maximum 7 possibleneighbors on the node level and 8 possible candidates

on the parent level. In order to minimize memory re-quirements, we can create a lookup table for directionvectors and store only an index to the vector. However,it is only required when our visualization algorithm isnot based on the ray tracing approach. Fig. 4 presentsan example of performing a continues transition.

Figure 4: Example of level transition based on the de-veloped method.

8 RESULTSIn this section, we present rendering results of the de-veloped algorithm. It is very difficult to present contin-uous LOD management on static images or even videosamples. A fundamental feature of the continuous LODtransition is to hide level changing from the observer.Fig. 5 - 6 demonstrates rendering the result of the de-veloped LOD management algorithm.

9 CONCLUSIONS AND FUTUREWORK

We have developed a novel approach for efficientreal-time rendering and controlling the SVO LOD.Our method can be used to algorithmically evaluatethe current LOD and perform a transition between twolevels. The pixel fill rate method instead of a distanceparameter allows for better control of virtual scenerendering results. Moreover, regardless of the chosenrendering method, we propose a universal patternnode evaluation method that can be used in real-time.In the case of the ray tracing approach, the requiredadditional data can be obtained from the renderingpass or based on the previous frame. In the case ofthe triangle based rasterization method based on theparallel reduce algorithm and GPU queries offersreal-time performance.

The LOD transition algorithm allows to perform a dy-namic and continues control of the SVO based objectswhich is our main contribution. By extending the SVOstructure with a new type of node called redundant nodewe achieved the full control of the level interpolationstage. Moreover, the proposed fading algorithm basedon the fade out direction and scaling allows for a LODchange without any graphical artifacts or loss of thevirtual scene immersion. The developed method is ap-plicable for various voxel rendering algorithms. More-over, the potential increase of memory consumption foradditional data has been minimized.

Figure 5: Object geometry and material transition example.

Figure 6: Example of the LOD management algorithm based on pixel fill rate evaluation for the single test object.

An obvious step forward would be to experiment withthe control of the entire virtual scene with numerousSVO objects. The current method is dedicated tocontrolling a per object LOD. Moreover, the proposedmethod does not perform the LOD evaluation in theview-depended style. We control the whole objectdetails even when we see just part of the object.

Last but not least, an interesting research can be con-ducted on the situation when we reached the highestLOD of the current object and still could get closer tothe object. In that case, the interesting solution seemsto be the procedural generation of the geometric com-plexity using e.g. displacement maps and tessellation.

10 REFERENCES[Bau11] Bautembach D., Animated sparse voxel oc-

trees, Bachelor Thesis, University of Hamburg,2011.

[Buck04] Buck, I., and Purcell, T., A Toolkit forComputation on GPUs, In GPU Gems, Addison-Wesley, 2004, pp. 621-636.

[Clark90] Clark, J.H, Seminal graphics. NewYork, NY, USA: ACM, 1998, ch. Hierar-chical Geometric Models for Visible SurfaceAlgorithms, pp. 43-50. [Online]. Available:http://doi.acm.org/10.1145/280811.280921

[Crassin11] Crassin, C., Neyret, F., Sainz, M., Green,S., and Eisemann, E., Interactive indirect illumi-nation using voxel cone tracing, Computer Graph-

ics Forum (Proceedings of Pacific Graphics 2011),vol. 30, no. 7, sep 2011.

[DeCoro07] DeCoro, C., and Tatarchuk, N., Real-timeMesh Simplification Using the GPU. Symposiumon Interactive 3D Graphics (I3D) 2007, pp. 6,April 2007.

[Garland97] Garland, M., and Heckbert, P. S. 1997.Surface simplification using quadric error metrics.Proceedings of ACM SIGGRAPH 1997, 209-216.

[Laine10] Laine, S., and Karras, T., Efficient sparsevoxel octrees, in Proceedings of the 2010 ACMSIGGRAPH Symposium on Interactive 3DGraphics and Games, ser. I3D 2010. New York,NY, USA: ACM, 2010, pp. 55-63.

[Lueb02] Luebke D., Watson B., Cohen, J., D., Reddy,M., and Varshney, A., Level of Detail for 3DGraphics. New York, NY, USA: Elsevier ScienceInc., 2002.

[Ramos06] Ramos, F., Chover, M., Ripolles, O., andGranell, C., DGCI, volume 4245 of Lecture Notesin Computer Science, page 460-469. Springer,2006

[Ripol12] Ripolles, O., Ramos, F., Puig-Centelles, A.,and Chover, M., 2012. Real-time tessellation ofterrain on graphics hardware. Comput. Geosci. 41(April 2012), 147-155.

[Rossignac93] Rossignac, J., and Borel, P., 1993.Multi-resolution 3D approximations for renderingcomplex scenes. Modeling in Computer Graphics:

Methods and Applications (June), 455-465.[Schaf14] Schäfer, H., Nießner, M., Keinert, B., Stam-

minger, M., and Loop, C., State of the art reporton real-time rendering with hardware tessellation,2014.

[Schiffner15] Schiffner, D., Stockhausen, C., Ritter,M. Surfaces for Point Clouds using Non-UniformGrids on the GPU, Short papers proceedingsWSCG2015.

[Schroeder92] Schroeder, W. J., Zagre, J. A., andLorense, W.E.1992. Decimation of trianglemeshes. In SIGGRAPH 92: Proceedings of the19th annual conference on Computer graphics andinteractive techniques, ACM Press, New York,NY, USA, 65-70.

[Shannon48] Shanno, C., E., A Mathematical Theoryof Communication, Bell System Technical Jour-nal 27(3).

[Stanford11] The Stanford 3D Scanning Repository,Stanford University, 22 Dec 2010, Retrieved 17July 2011.

[Tanen07] Tanenbaum, A. S., Modern Operating Sys-tems, 3rd ed. Upper Saddle River, NJ, USA: Pren-tice Hall Press, 2007.

[Wil13] Willcocks, C. G., Sparse volumetric defor-mation, Ph.D. dissertation, Durham University,2013.

[Willmott11] Willmott, A., Rapid Simplification ofMulti-attribute Meshes, Proceedings of the ACMSIGGRAPH Symposium on High PerformanceGraphics, 2011.

[Wright10] Wright, R., S., Haemel, N., Sellers, G.,Lipchak, B., OpenGL SuperBible: Comprehen-sive Tutorial and Reference, Addison-Wesley Pro-fessional, 2010.

Last page should be fully used by text, figures etc.Do not leave empty space, please.Do not lock the PDF – additional text and info willbe inserted, i.e. ISSN/ISBN etc.