# Examination of the evidence for a proton halo in 22Al

K. Y. Zhang  0000-0002-8404-2528 Institute of Nuclear Physics and Chemistry,
China Academy of Engineering Physics, Mianyang, Sichuan 621900, China  C. Pan
0000-0003-3675-8238<EMAIL_ADDRESS>Department of Physics, Anhui Normal
University, Wuhu, Anhui 241000, China  Sibo Wang  0000-0002-2050-0040
Department of Physics and Chongqing Key Laboratory for Strongly Coupled
Physics, Chongqing University, Chongqing 401331, China

###### Abstract

More and more halo nuclei or candidates have been identified or suggested in
experiments in recent years. It was declared that the halo structure of 22Al
is revealed by the large isospin asymmetry in 22Si/22O mirror Gamow-Teller
transitions [Phys. Rev. Lett. 125, 192503 (2020)]. We highlight that a
significant mirror asymmetry already exists between wave functions of the
likely unbound nucleus 22Si and the doubly-magic nucleus 22O, which largely
explains the observed asymmetry in the transitions. Furthermore, these
transitions involve only the $1^{+}$ excited states of the daughter nuclei
22Al and 22F. The $1^{+}$ state of 22Al cannot be considered a halo state due
to its proton-unbound nature. An analysis of the spin parity suggests that a
weakly bound $2s_{1/2}$ valence proton in the ground state of 22Al is
improbable. To investigate the shell structure for the ground state of 22Al,
we employ the state-of-the-art deformed and triaxial relativistic Hartree-
Bogoliubov theories in continuum. We find that a small $s$-wave component of
$5\%$ appears for the weakly bound valence proton in 22Al only when triaxial
deformation is considered. While the examination of densities and rms radii
indicates that this small $s$-wave component is insufficient to form a
discernible proton halo in 22Al, slightly larger $2s_{1/2}$ occupations have
been reported in other recent theoretical results. The question of how many
low-$\ell$ components are sufficient to form a proton halo in the presence of
the Coulomb barrier remains open. Thus, future measurements of reaction or
interaction cross sections and momentum distributions of breakup fragments are
highly desirable to verify whether 22Al is a halo nucleus.

##  I Introduction

In 1985, Tanihata et al. [1] measured the interaction cross sections
$\sigma_{I}$ for ${}^{6\text{--}9,11}$Li on targets Be, C, and Al at 790
MeV/nucleon. The root-mean-square (rms) radii of these lithium isotopes were
deduced from the measured $\sigma_{I}$ by a Glauber-type calculation.
Surprisingly, 11Li exhibited a remarkably larger radius, $3.27\pm 0.24$ fm,
compared with those of approximately 2.5 fm for ${}^{6\text{--}9}$Li. This was
attributed to a large deformation or a long tail in the matter distribution in
11Li.

In 1988, Kobayashi et al. [2] measured the projectile fragmentation of 11Li at
790 MeV/nucleon. An extremely narrow width of the transverse momentum
distribution of the 9Li fragmentation was observed. This narrow width was
understood to originate from the removal of the two weakly bound outer
neutrons in 11Li. They form a halo-like structure enveloping the core nucleus
9Li, and such an unprecedented, exotic phenomenon is thus termed “neutron
halo.”

Since then, it has become a paradigm that the identification of a halo nucleus
necessitates the observation of both an enhancement in the cross section and a
narrow momentum distribution of the breakup fragments [3]. In addition, some
other features such as a low nucleon separation energy and a soft $E1$
excitation are indicative of a possible halo [4, 5].

To date, about 20 halo nuclei or candidates have been identified or suggested
in experiments (see Fig. 1.4 of Ref. [3] and Fig. 1 of Ref. [6]). It is
noteworthy that there also could be proton halos in proton-rich nuclei, e.g.,
8B [7, 8, 9]. However, due to the effects of the Coulomb barrier [10], the
number of proton halo nuclei and candidates is less than that of neutron halo
ones.

In 2020, a large mirror asymmetry of $\delta=209(96)\%$ was reported for the
transition of 22Si/22O partner to the first $1^{+}$ excited state of their
respective daughter 22Al/22F [11]. It was declared in Ref. [11] that this
asymmetry “reveals the halo structure of 22Al.” However, neither an enhanced
interaction/reaction cross section nor a narrow momentum distribution of
breakup fragments was observed for 22Al. Moreover, the results presented in
Ref. [11] pertain only to the $1^{+}$ excited states of 22Al, while its
ground-state configuration remains uncertain.

In this paper, we discuss whether it is solid to suggest 22Al as a halo
nucleus from the existing experimental information. Besides, based on the
state-of-the-art deformed and triaxial relativistic Hartree-Bogoliubov
theories in continuum, we examine the possibility of a proton halo in the
ground state of 22Al.

##  II The experiment in 2020

First, we introduce some details from Ref. [11] for the convenience of the
following discussion. The asymmetry parameter is defined as
$\delta=ft^{+}/ft^{-}-1$, where $ft^{\pm}$ is the reduced Gamow-Teller (GT)
transition probability of the $\beta^{\pm}$ decay,

$ft=\frac{D}{(\frac{g_{A}}{g_{V}})^{2}_{\mathrm{eff}}|M_{\mathrm{GT}}|^{2}}.$
(1)

$D$ and $(g_{A}/g_{V})_{\mathrm{eff}}$ are coupling constants and are
considered unchanged for mirror transition processes [11]. $M_{\mathrm{GT}}$
is the nuclear matrix element,

$M_{\mathrm{GT}}=\langle\mathrm{final~{}state}|\tau\sigma|\mathrm{initial~{}state}\rangle,$
(2)

where $\tau$ and $\sigma$ are the isospin transition and Pauli spin matrices,
respectively. The asymmetry parameter then reads

$\delta=\frac{ft^{+}}{ft^{-}}-1=\frac{|M_{\mathrm{GT}}^{-}|^{2}}{|M_{\mathrm{GT}}^{+}|^{2}}-1.$
(3)

A basic logic presented in Ref. [11] can be understood as follows.

  1. (1)

If there is a halo in the drip-line nucleus 22Al, its wave function will be
spread out over a wide region.

  2. (2)

Its mirror nucleus 22F is relatively tightly bound with a one-neutron
separation energy of 5230(13) keV [12] and is away from the drip line (31F
[13]) by nine neutrons.

  3. (3)

The difference in the final states will lead to very different nuclear matrix
elements (2) for 22Si $\rightarrow$ 22Al and 22O $\rightarrow$ 22F
transitions, giving a large $\delta$ value (3).

While a possible explanation for the observed mirror asymmetry was provided,
it should be noted that the above discussion solely concerns the final states
in the transitions. Namely, it is based on a crucial premise that the initial
states of 22Si and 22O are essentially similar. This is, however, likely not
true.

The $N=14$ shell closure in 22O has been recognized for several years [14,
15], and the recent measurement on the rms radii of proton density
distributions for oxygen isotopes further supports the double magicity of 22O
[16]. Consequently, 22O is compact in nature, as also evidenced by its sizable
two-neutron separation energy of 10656(57) keV [12]. In contrast, its mirror
partner 22Si is probably an unbound system beyond the proton drip line. Based
on the observation of $\beta$-delayed two-proton emission in the decay of
22Si, its two-proton separation energy is deduced to be $-108(125)$ keV [17].
In the latest atomic mass evaluation (AME2020) [12], the extrapolated value
for the two-proton separation energy of 22Si is $-1584(500)$ keV. Whether 22Si
is unbound or very weakly bound, its density distribution can be rather
diffuse, e.g., see results from the relativistic mean-field theory in Ref.
[18]. In fact, the two-proton radioactivity of 22Si and the corresponding
decay half-life have been predicted by many theoretical models [19, 20, 21,
22, 23]. Therefore, a significant mirror asymmetry has already existed in the
wave functions of 22Si and 22O, which would be responsible for the large
$\delta$ to a considerable extent. Given also that the discussion in Ref. [11]
concentrates on the $1^{+}$ excited state of 22Al, it warrants careful
consideration to conclude that the halo structure of 22Al is revealed.
Furthermore, even if the $1^{+}$ state could contain certain $s$ component, it
is proton-unbound in nature and, thus, cannot be considered as a halo state.

Figure 1: Experimental level schemes for low-lying states below 4 MeV of 21Mg
and the ground state of 22Al [25, 26]. Spin parities $J^{\pi}$ and energies
(in keV, with respect to the ground-state 21Mg, and neglecting uncertainties)
are given for each level. The bracket indicates that $J^{\pi}$ are not
completely determined.

##  III Ground-state analysis

Next, we discuss the ground state of 22Al. Its mirror nucleus 22F has a
ground-state spin parity of $4^{+}$ and an excited $3^{+}$ state at 72 keV. If
the ground-state spin parity of 22Al is $3^{+}$, there might be a chance of a
halo if it contains enough parentage of 21Mg (whose ground-state spin parity
is $5/2^{+}$) coupled to a $2s_{1/2}$ proton. However, the $\beta$ decay of
22Al strongly suggests a $4^{+}$ ground-state spin parity [24], which
necessitates a spin no less than $3/2$ for the valence proton when coupled to
the ground-state 21Mg. Even if the $4^{+}$ state has some $\pi 2s_{1/2}$
occupation, the parentage has to be to $7/2^{+}$ or $9/2^{+}$ states of 21Mg,
and the first candidates are at 3347 and 3643 keV [25], as shown in Fig. 1.
The one-proton separation energy of 22Al is recently measured to be 100.4(8)
keV [26]. This means that the separation energy of a $2s_{1/2}$ proton from
the ground-state 22Al is at least approximately $3447~{}(3347+100)$ keV, which
seems unfavorable for the formation of a proton halo. Nonetheless, one cannot
completely rule out the possibility of a small $s$-orbital component, which
might correspond to a definite but not dominant halo [27].

In the conventional single-particle shell model, the valence proton in 22Al
would occupy the $1d_{5/2}$ orbital, which could provide the correct spin
parity but does not promote the formation of a halo due to the centrifugal
barrier. Since 22Al is an open-shell drip-line nucleus, the deformation,
pairing correlations, and continuum effects play indispensable roles in its
microscopic description. Therefore, the deformed relativistic Hartree-
Bogoliubov theory in continuum (DRHBc) [28, 29, 30, 31] could provide valuable
insights. The DRHBc theory has been successfully applied to the microscopic
description of known halo nuclei 17,19B [27, 32], 15,19,22C [33, 34], 31Ne
[35, 36], and 37Mg [37, 38], the prediction of new halo candidates 39Na [6]
and 42,44Mg [28, 29, 39], and the exploration of the limits of nuclear
existence [40, 41, 42, 43, 44, 45, 46]. While mean-field calculations cannot
yield states with well-defined spins, in the DRHBc theory the angular momentum
can be analyzed based on the main components of the valence nucleon(s) and
compared with experiments, as a spherical Dirac Woods-Saxon basis [47, 48]
that possesses good quantum numbers is used to expand wave functions. In this
regard, the implementation of angular momentum projection in the DRHBc theory
[49, 50] for odd-odd nuclei in future work is also desirable.

In Ref. [51], the potential energy curves with different proton and neutron
orbitals blocked have been constructed for 22Al using the DRHBc theory with
the density functional PC-PK1 [52]. It can be found in Figs. 1 and 2 of Ref.
[51] that the ground state of 22Al is deformed with $\beta_{2}\approx 0.3$,
and the valence proton occupies an orbital with quantum numbers
$\Omega^{\pi}=5/2^{+}$, where $\pi$ denotes the parity and $\Omega$ is the
projection of the total angular momentum on the symmetry axis. The results
show that this orbital has more than $99\%$ $1d_{5/2}$ component. The
$1d_{5/2}$ component is also overwhelmingly dominant for the valence neutron
in both 22Al and 21Mg. This is consistent with the $5/2^{+}$ spin parity for
the ground-state 21Mg and the fact that the $4^{+}$ ground state of 22Al can
be obtained from the parentage of the ground state of 21Mg coupled to a
$1d_{5/2}$ proton. However, we note that the $2s_{1/2}$ component cannot
contribute to the valence proton in 22Al since its total angular momentum
quantum number $j=1/2$ is smaller than $\Omega=5/2$. Therefore, the ground-
state halo structure of 22Al is not supported by the DRHBc theory that assumes
the axial symmetry.

A recent calculation based on a Woods-Saxon potential suggests that the region
of halo nuclei could be extended by triaxial deformation that allows the
appearance of $s$\- or $p$-wave components in some weakly bound orbitals [53].
It would be interesting to examine whether triaxial deformation plays a role
in the ground state of 22Al. To this end, we resort to the triaxial
relativistic Hartree-Bogoliubov theory in continuum (TRHBc) [54], which
incorporates triaxiality, pairing correlations, and continuum effects in a
microscopic and self-consistent way.

The calculated one-proton separation energy is positive for 22Al but negative
for 21Al, i.e., the proton drip-line location for aluminum isotopes [24] is
correctly reproduced by the TRHBc theory [54]. The TRHBc results from various
density functionals are also in good agreement with available data for neutron
separation energies and charge radii of aluminum isotopes [54]. Here, taking
the density functional PC-F1 [55] as an example, we focus on the ground-state
properties of 22Al. Other numerical details in our calculation are the same as
those used in Ref. [54].

Figure 2: Energy $\varepsilon_{p}$ versus occupation probability $v^{2}$ for
single-proton orbitals around the Fermi energy $\lambda_{p}$ (dashed line) in
the canonical basis for 22Al from (a) TRHBc and (b) DRHBc calculations. Each
orbital is labeled by quantum number(s) $\pi$ in (a) and $\Omega^{\pi}$ in
(b). The orbital occupied by the valence proton is in red, and its components
are given in the square brackets.

The calculated binding energy of $149544.8$ keV reproduces well the recently
measured result of $149313.1(3)$ keV [26], with a discrepancy below $0.01\%$.
However, the calculated one-proton separation energy of $21.7$ keV is only
about one-fifth of the experimental one, $100.4(8)$ keV [26], which means that
the TRHBc theory describes 22Al as more weakly bound than it actually is. The
ground-state deformation parameters are $\beta=0.30$ and $\gamma=7.93^{\circ}$
for 22Al, that is, slight triaxial deformation occurs. To explore the effects
of triaxial deformation, we exhibit in Fig. 2(a) the single-proton orbitals
around the Fermi energy in the canonical basis for 22Al from the TRHBc
calculation, in comparison with those from the DRHBc calculation in Fig. 2(b).
We find that the influence of triaxial deformation is on the order of 0.01 MeV
for both the single-proton energies and the binding energy. Nonetheless, due
to the breaking of axial symmetry, $\Omega$ is no longer a good quantum
number, which allows the appearance of $2s_{1/2}$ component in the weakly
bound orbital occupied by the valence proton. This is similar to the scenario
discussed in Ref. [53] for nuclei with $N=13$ based on a Woods-Saxon
potential; here, $Z=13$. Quantitatively, there are about $93\%$ $1d_{5/2}$ and
$5\%$ $2s_{1/2}$ components.

Figure 3: Angle-averaged proton density as a function of radial coordinate $r$
for $N=9$ isotones with the proton number ranging from 8 (17O) to 13 (22Al).
For 22Al, the TRHBc and DRHBc results are shown by short-dashed and dashed
lines, respectively. For other isotones, the TRHBc and DRHBc theories yield
the same results.

The inclusion of $2s_{1/2}$ component in the valence proton orbital is
expected to extend the proton density distribution in 22Al. To investigate
this effect, we present the angle-averaged proton densities for $N=9$ isotones
with $8\leq Z\leq 13$ in Fig. 3. The TRHBc and DRHBc results for 22Al are
represented by short-dashed and dashed lines, respectively, while for other
lighter isotones the TRHBc and DRHBc results are identical. Specifically, 17O,
18F, 19Ne, 20Na, and 21Mg are predicted to be axially deformed in their ground
states with $\beta_{2}=-0.08$, $0.27$, $0.26$, $0.42$, and $0.32$,
respectively. Figure 3 shows that near the central region ($r\lesssim 4$ fm),
the proton density gradually increases with $Z$. At larger $r$, there is a
notable increase in the proton density from an even-$Z$ isotone to the next
heavier odd-$Z$ isotone. The proton density of this odd-$Z$ isotone can even
exceed that of the next heavier even-$Z$ isotone beyond $r\approx 10$ fm.
These are primarily due to the blocking effect of the odd nucleon in extending
density [34], with deformation effects also contributing. For 22Al, the
difference between the TRHBc and DRHBc results becomes evident only in the
region of $r\gtrsim 10$ fm. In this region, the proton density of 22Al with
$Z=13$ is approximately one order of magnitude lower than the neutron density
of the known neutron halo nucleus 17B with $N=12$ (see Fig. 3 of the
supplemental material of Ref. [27]).

Figure 4: Proton, neutron, and matter rms radii for $N=9$ isotones with the
proton number ranging from 8 (17O) to 13 (22Al). For 22Al, the TRHBc and DRHBc
results are shown by solid and open symbols (almost overlapped), respectively.
For other isotones, the TRHBc and DRHBc theories yield the same results that
are shown by open symbols.

The slightly more diffuse proton density, attributable to the minor $2s_{1/2}$
component, corresponds to a marginal increase in the proton rms radius of
22Al. This is depicted in Fig. 4, which presents the proton, neutron, and
matter rms radii for $N=9$ isotones with $8\leq Z\leq 13$. While the proton
rms radius increases steadily with $Z$, the neutron rms radius remains almost
unchanged, and the matter rms radius lies between the two. The differences in
neutron and matter rms radii between the TRHBc and DRHBc results for 22Al are
almost indistinguishable. As shown in Fig. 4, the most significant increase in
the proton rms radius occurs from 19Ne to 20Na, due to deformation effects,
rather than from 21Mg to 22Al. Consequently, the $2s_{1/2}$ component of only
$5\%$ appears insufficient to form a discernible proton halo in the present
calculation.

Of course, the $s$-wave component may vary depending on the employed pairing
strength and density functional. Further calculations indicate that triaxial
deformation and the $2s_{1/2}$ component can be enhanced by pairing. For
instance, increasing the pairing strength from $V_{0}=-342.5$ MeV fm3 to
$-350$ MeV fm3 results in deformation parameters for 22Al of $\beta=0.29$ and
$\gamma=9.33^{\circ}$, with the $2s_{1/2}$ component increasing to $8\%$.
However, this enhanced pairing renders the one-proton separation energy of
22Al negative, as 22Al gains less binding energy than the even-$Z$ nucleus
21Mg. While the TRHBc calculations with other density functionals such as PC-
PK1 yield similar results as above, the ab initio valence-space in-medium
similarity renormalization group calculations employing four sets of chiral
interactions predict a somewhat larger $\pi 2s_{1/2}$ occupation of $\lesssim
0.2$ for the ground state 22Al [56]. Additionally, a larger $\pi 2s_{1/2}$
occupation of 0.29 is predicted by shell-model calculations using USD
Hamiltonians [26].

It was generally accepted that a significant quantity of low-$\ell$ components
are necessary for halo formation. However, a small $s$-wave component of
$9(2)\%$ has been observed and reproduced by the DRHBc theory for the halo
nucleus 17B, indicating that the dominant occupation of $s$ or $p$ orbitals is
not a prerequisite for a neutron halo [27]. On the other hand, the Coulomb
barrier hinders the formation of a proton halo. Therefore, here we cannot draw
a firm conclusion on whether 22Al is a halo nucleus, but our results
demonstrate that the appearance of $s$-wave components for the valence proton
in 22Al necessitates the consideration of triaxial deformation at the mean-
field level.

##  IV Summary

In summary, we argue that it is unconvincing to suggest a proton halo in 22Al
based on the large mirror asymmetry observed in the 22Si/22O $\rightarrow$
22Al/22F transitions. First, this asymmetry can be largely attributed to the
differences between the wave functions of the doubly magic nucleus 22O and the
likely unbound nucleus 22Si. Second, the transitions involve the $1^{+}$
excited states rather than the ground states of 22Al and 22F. Third, even if
the $1^{+}$ state of 22Al contains some $s$-wave component, it cannot be
considered a halo state due to its proton-unbound nature.

An analysis of the spin parity suggests that a weakly bound $2s_{1/2}$ valence
proton in the ground-state 22Al is improbable. The ground state of 22Al is
investigated using the DRHBc and TRHBc theories. A small $s$-wave component of
$5\%$ appears for the weakly bound valence proton in 22Al only when triaxial
deformation is considered. Examination of densities and rms radii indicates
that this small $s$-wave component is insufficient to form a discernible
proton halo in 22Al. Nevertheless, other recent theoretical calculations have
yielded slightly larger $\pi 2s_{1/2}$ occupations for the ground state of
22Al. Since how many low-$\ell$ components are sufficient to form a proton
halo in the presence of the Coulomb barrier remains an open question, a firm
conclusion on whether 22Al is a halo nucleus has not been obtained. Future
measurements of reaction or interaction cross sections and momentum
distributions of breakup fragments for 22Al are highly desirable.

###### Acknowledgements.

We greatly appreciate the anonymous referees for extending our discussion to
involve the ground-state spin parity, densities, and rms radii. We thank X.
Lu, J. Meng, P. Papakonstantinou, and S. Q. Zhang for helpful suggestions and
discussions. This work was partly supported by the National Natural Science
Foundation of China (Grants No. 12305125 and No. 12205030) and the Sichuan
Science and Technology Program (Grant No. 2024NSFSC1356).

## References

  * Tanihata  _et al._ [1985] I. Tanihata, H. Hamagaki, O. Hashimoto, Y. Shida, N. Yoshikawa, K. Sugimoto, O. Yamakawa, T. Kobayashi, and N. Takahashi, Measurements of interaction cross sections and nuclear radii in the light $p$-shell region, Phys. Rev. Lett. 55, 2676 (1985).
  * Kobayashi  _et al._ [1988] T. Kobayashi, O. Yamakawa, K. Omata, K. Sugimoto, T. Shimoda, N. Takahashi, and I. Tanihata, Projectile fragmentation of the extremely neutron-rich nucleus ${}^{11}\mathrm{Li}$ at 0.79 GeV/nucleon, Phys. Rev. Lett. 60, 2599 (1988).
  * Tanihata  _et al._ [2013] I. Tanihata, H. Savajols, and R. Kanungo, Recent experimental progress in nuclear halo structure studies, Prog. Part. Nucl. Phys. 68, 215 (2013).
  * Tanihata  _et al._ [2023] I. Tanihata, H. Toki, and T. Kajino, eds.,  _Handbook of Nuclear Physics_ (Springer, Singapore, 2023).
  * Aumann and Nakamura [2013] T. Aumann and T. Nakamura, The electric dipole response of exotic nuclei, Phys. Scr. 2013, 014012 (2013).
  * Zhang  _et al._ [2023a] K. Y. Zhang, P. Papakonstantinou, M.-H. Mun, Y. Kim, H. Yan, and X.-X. Sun, Collapse of the $N=28$ shell closure in the newly discovered ${}^{39}\mathrm{Na}$ nucleus and the development of deformed halos towards the neutron dripline, Phys. Rev. C 107, L041303 (2023a).
  * Warner  _et al._ [1995] R. E. Warner, J. H. Kelley, P. Zecher, F. D. Becchetti, J. A. Brown, C. L. Carpenter, A. Galonsky, J. Kruse, A. Muthukrishnan, A. Nadasen, R. M. Ronningen, P. Schwandt, B. M. Sherrill, J. Wang, and J. S. Winfield, Evidence for a proton halo in ${}^{8}\mathrm{B}$: Enhanced total reaction cross sections at 20 to 60 MeV/nucleon, Phys. Rev. C 52, R1166 (1995).
  * Kelley  _et al._ [1996] J. H. Kelley, S. M. Austin, A. Azhari, D. Bazin, J. A. Brown, H. Esbensen, M. Fauerbach, M. Hellström, S. E. Hirzebruch, R. A. Kryger, D. J. Morrissey, R. Pfaff, C. F. Powell, E. Ramakrishnan, B. M. Sherrill, M. Steiner, T. Suomijärvi, and M. Thoennessen, Study of the breakup reaction ${}^{8}\mathrm{B}\rightarrow{}^{7}\mathrm{Be}\mathrm{}+\mathit{p}$: Absorption effects and $\mathit{E}2$ strength, Phys. Rev. Lett. 77, 5020 (1996).
  * Smedberg  _et al._ [1999] M. Smedberg, T. Baumann, T. Aumann, L. Axelsson, U. Bergmann, M. Borge, D. Cortina-Gil, L. Fraile, H. Geissel, L. Grigorenko, M. Hellström, M. Ivanov, N. Iwasa, R. Janik, B. Jonson, H. Lenske, K. Markenroth, G. Münzenberg, T. Nilsson, A. Richter, K. Riisager, C. Scheidenberger, G. Schrieder, W. Schwab, H. Simon, B. Sitar, P. Strmen, K. Sümmerer, M. Winkler, and M. Zhukov, New results on the halo structure of ${}^{8}\mathrm{B}$, Phys. Lett. B 452, 1 (1999).
  * Riisager  _et al._ [1992] K. Riisager, A. Jensen, and P. Møller, Two-body halos, Nucl. Phys. A 548, 393 (1992).
  * Lee  _et al._ [2020] J. Lee, X. X. Xu, K. Kaneko, Y. Sun, C. J. Lin, L. J. Sun, P. F. Liang, Z. H. Li, J. Li, H. Y. Wu, D. Q. Fang, J. S. Wang, Y. Y. Yang, C. X. Yuan, Y. H. Lam, Y. T. Wang, K. Wang, J. G. Wang, J. B. Ma, J. J. Liu, P. J. Li, Q. Q. Zhao, L. Yang, N. R. Ma, D. X. Wang, F. P. Zhong, S. H. Zhong, F. Yang, H. M. Jia, P. W. Wen, M. Pan, H. L. Zang, X. Wang, C. G. Wu, D. W. Luo, H. W. Wang, C. Li, C. Z. Shi, M. W. Nie, X. F. Li, H. Li, P. Ma, Q. Hu, G. Z. Shi, S. L. Jin, M. R. Huang, Z. Bai, Y. J. Zhou, W. H. Ma, F. F. Duan, S. Y. Jin, Q. R. Gao, X. H. Zhou, Z. G. Hu, M. Wang, M. L. Liu, R. F. Chen, and X. W. Ma (RIBLL Collaboration), Large isospin asymmetry in ${}^{22}\mathrm{Si}/^{22}\mathrm{O}$ mirror Gamow-Teller transitions reveals the halo structure of ${}^{22}\mathrm{Al}$, Phys. Rev. Lett. 125, 192503 (2020).
  * Wang  _et al._ [2021] M. Wang, W. Huang, F. Kondev, G. Audi, and S. Naimi, The AME 2020 atomic mass evaluation (II). tables, graphs and references, Chin. Phys. C 45, 030003 (2021).
  * Ahn  _et al._ [2019] D. S. Ahn, N. Fukuda, H. Geissel, N. Inabe, N. Iwasa, T. Kubo, K. Kusaka, D. J. Morrissey, D. Murai, T. Nakamura, M. Ohtake, H. Otsu, H. Sato, B. M. Sherrill, Y. Shimizu, H. Suzuki, H. Takeda, O. B. Tarasov, H. Ueno, Y. Yanagisawa, and K. Yoshida, Location of the neutron dripline at fluorine and neon, Phys. Rev. Lett. 123, 212501 (2019).
  * Stanoiu  _et al._ [2004] M. Stanoiu, F. Azaiez, Z. Dombrádi, O. Sorlin, B. A. Brown, M. Belleguic, D. Sohler, M. G. Saint Laurent, M. J. Lopez-Jimenez, Y. E. Penionzhkevich, G. Sletten, N. L. Achouri, J. C. Angélique, F. Becker, C. Borcea, C. Bourgeois, A. Bracco, J. M. Daugas, Z. Dlouhý, C. Donzaud, J. Duprat, Z. Fülöp, D. Guillemaud-Mueller, S. Grévy, F. Ibrahim, A. Kerek, A. Krasznahorkay, M. Lewitowicz, S. Leenhardt, S. Lukyanov, P. Mayet, S. Mandal, H. van der Marel, W. Mittig, J. Mrázek, F. Negoita, F. De Oliveira-Santos, Z. Podolyák, F. Pougheon, M. G. Porquet, P. Roussel-Chomaz, H. Savajols, Y. Sobolev, C. Stodel, J. Timár, and A. Yamamoto, $N=14$ and 16 shell gaps in neutron-rich oxygen isotopes, Phys. Rev. C 69, 034312 (2004).
  * Becheva  _et al._ [2006] E. Becheva, Y. Blumenfeld, E. Khan, D. Beaumel, J. M. Daugas, F. Delaunay, C.-E. Demonchy, A. Drouart, M. Fallot, A. Gillibert, L. Giot, M. Grasso, N. Keeley, K. W. Kemper, D. T. Khoa, V. Lapoux, V. Lima, A. Musumarra, L. Nalpas, E. C. Pollacco, O. Roig, P. Roussel-Chomaz, J. E. Sauvestre, J. A. Scarpaci, F. Skaza, and H. S. Than, $N=14$ shell closure in ${}^{22}\mathrm{O}$ viewed through a neutron sensitive probe, Phys. Rev. Lett. 96, 012501 (2006).
  * Kaur  _et al._ [2022] S. Kaur, R. Kanungo, W. Horiuchi, G. Hagen, J. D. Holt, B. S. Hu, T. Miyagi, T. Suzuki, F. Ameil, J. Atkinson, Y. Ayyad, S. Bagchi, D. Cortina-Gil, I. Dillmann, A. Estradé, A. Evdokimov, F. Farinon, H. Geissel, G. Guastalla, R. Janik, R. Knöbel, J. Kurcewicz, Y. A. Litvinov, M. Marta, M. Mostazo, I. Mukha, C. Nociforo, H. J. Ong, T. Otsuka, S. Pietri, A. Prochazka, C. Scheidenberger, B. Sitar, P. Strmen, M. Takechi, J. Tanaka, I. Tanihata, S. Terashima, J. Vargas, H. Weick, and J. S. Winfield, Proton distribution radii of ${}^{16\text{--}24}\mathrm{O}$: Signatures of new shell closures and neutron skin, Phys. Rev. Lett. 129, 142502 (2022).
  * Xu  _et al._ [2017] X. Xu, C. Lin, L. Sun, J. Wang, Y. Lam, J. Lee, D. Fang, Z. Li, N. Smirnova, C. Yuan, L. Yang, Y. Wang, J. Li, N. Ma, K. Wang, H. Zang, H. Wang, C. Li, M. Liu, J. Wang, C. Shi, M. Nie, X. Li, H. Li, J. Ma, P. Ma, S. Jin, M. Huang, Z. Bai, F. Yang, H. Jia, Z. Liu, D. Wang, Y. Yang, Y. Zhou, W. Ma, J. Chen, Z. Hu, M. Wang, Y. Zhang, X. Ma, X. Zhou, Y. Ma, H. Xu, G. Xiao, and H. Zhang, Observation of $\beta$-delayed two-proton emission in the decay of ${}^{22}\mathrm{Si}$, Phys. Lett. B 766, 312 (2017).
  * Saxena  _et al._ [2017] G. Saxena, M. Kumawat, M. Kaushik, S. Jain, and M. Aggarwal, Two-proton radioactivity with $2p$ halo in light mass nuclei $A=18\text{--}34$, Phys. Lett. B 775, 126 (2017).
  * Gonçalves  _et al._ [2017] M. Gonçalves, N. Teruya, O. Tavares, and S. Duarte, Two-proton emission half-lives in the effective liquid drop model, Phys. Lett. B 774, 14 (2017).
  * Sreeja and Balasubramaniam [2019] I. Sreeja and M. Balasubramaniam, An empirical formula for the half-lives of exotic two-proton emission, Eur. Phys. J. A 55, 33 (2019).
  * Cui  _et al._ [2020] J. P. Cui, Y. H. Gao, Y. Z. Wang, and J. Z. Gu, Two-proton radioactivity within a generalized liquid drop model, Phys. Rev. C 101, 014301 (2020).
  * Xing  _et al._ [2021] F. Xing, J. Cui, Y. Wang, and J. Gu, Two-proton radioactivity of ground and excited states within a unified fission model, Chin. Phys. C 45, 124105 (2021).
  * Mehana and Rajeswari [2023] P. Mehana and N. S. Rajeswari, Two-proton and one-proton emission of two-proton emitters, Eur. Phys. J. A 59, 104 (2023).
  * Wu  _et al._ [2021] C. G. Wu, H. Y. Wu, J. G. Li, D. W. Luo, Z. H. Li, H. Hua, X. X. Xu, C. J. Lin, J. Lee, L. J. Sun, P. F. Liang, C. X. Yuan, Y. Y. Yang, J. S. Wang, D. X. Wang, F. F. Duan, Y. H. Lam, P. Ma, Z. H. Gao, Q. Hu, Z. Bai, J. B. Ma, J. G. Wang, F. P. Zhong, Y. Jiang, Y. Liu, D. S. Hou, R. Li, N. R. Ma, W. H. Ma, G. Z. Shi, G. M. Yu, D. Patel, S. Y. Jin, Y. F. Wang, Y. C. Yu, Q. W. Zhou, P. Wang, L. Y. Hu, S. Q. Fan, X. Wang, H. L. Zang, P. J. Li, Q. Q. Zhao, L. Yang, P. W. Wen, F. Yang, H. M. Jia, G. L. Zhang, M. Pan, X. Y. Wang, H. H. Sun, Z. G. Hu, M. L. Liu, R. F. Chen, W. Q. Yang, S. Q. Hou, J. J. He, Y. M. Zhao, F. R. Xu, and H. Q. Zhang (RIBLL Collaboration), $\beta$-decay spectroscopy of the proton drip-line nucleus ${}^{22}\mathrm{Al}$, Phys. Rev. C 104, 044311 (2021).
  * [25] National Nuclear Data Center (NNDC), http://www.nndc.bnl.gov/.
  * Campbell  _et al._ [2024] S. E. Campbell, G. Bollen, B. A. Brown, A. Dockery, C. M. Ireland, K. Minamisono, D. Puentes, B. J. Rickey, R. Ringle, I. T. Yandow, K. Fossez, A. Ortiz-Cortes, S. Schwarz, C. S. Sumithrarachchi, and A. C. C. Villari, Precision Mass Measurement of the Proton Dripline Halo Candidate ${}^{22}\mathrm{Al}$, Phys. Rev. Lett. 132, 152501 (2024).
  * Yang  _et al._ [2021] Z. H. Yang, Y. Kubota, A. Corsi, K. Yoshida, X.-X. Sun, J. G. Li, M. Kimura, N. Michel, K. Ogata, C. X. Yuan, Q. Yuan, G. Authelet, H. Baba, C. Caesar, D. Calvet, A. Delbart, M. Dozono, J. Feng, F. Flavigny, J.-M. Gheller, J. Gibelin, A. Giganon, A. Gillibert, K. Hasegawa, T. Isobe, Y. Kanaya, S. Kawakami, D. Kim, Y. Kiyokawa, M. Kobayashi, N. Kobayashi, T. Kobayashi, Y. Kondo, Z. Korkulu, S. Koyama, V. Lapoux, Y. Maeda, F. M. Marqués, T. Motobayashi, T. Miyazaki, T. Nakamura, N. Nakatsuka, Y. Nishio, A. Obertelli, A. Ohkura, N. A. Orr, S. Ota, H. Otsu, T. Ozaki, V. Panin, S. Paschalis, E. C. Pollacco, S. Reichert, J.-Y. Roussé, A. T. Saito, S. Sakaguchi, M. Sako, C. Santamaria, M. Sasano, H. Sato, M. Shikata, Y. Shimizu, Y. Shindo, L. Stuhl, T. Sumikama, Y. L. Sun, M. Tabata, Y. Togano, J. Tsubota, F. R. Xu, J. Yasuda, K. Yoneda, J. Zenihiro, S.-G. Zhou, W. Zuo, and T. Uesaka, Quasifree neutron knockout reaction reveals a small $s$-orbital component in the Borromean nucleus ${}^{17}\mathrm{B}$, Phys. Rev. Lett. 126, 082501 (2021).
  * Zhou  _et al._ [2010] S.-G. Zhou, J. Meng, P. Ring, and E.-G. Zhao, Neutron halo in deformed nuclei, Phys. Rev. C 82, 011301 (2010).
  * Li  _et al._ [2012] L. Li, J. Meng, P. Ring, E.-G. Zhao, and S.-G. Zhou, Deformed relativistic Hartree-Bogoliubov theory in continuum, Phys. Rev. C 85, 024312 (2012).
  * Li  _et al._ [2012b] L. Li, J. Meng, P. Ring, E.-G. Zhao, and S.-G. Zhou, Odd systems in deformed relativistic Hartree-Bogoliubov theory in continuum, Chin. Phys. Lett. 29, 042101 (2012b).
  * Zhang  _et al._ [2020] K. Zhang, M.-K. Cheoun, Y.-B. Choi, P. S. Chong, J. Dong, L. Geng, E. Ha, X. He, C. Heo, M. C. Ho, E. J. In, S. Kim, Y. Kim, C.-H. Lee, J. Lee, Z. Li, T. Luo, J. Meng, M.-H. Mun, Z. Niu, C. Pan, P. Papakonstantinou, X. Shang, C. Shen, G. Shen, W. Sun, X.-X. Sun, C. K. Tam, Thaivayongnou, C. Wang, S. H. Wong, X. Xia, Y. Yan, R. W.-Y. Yeung, T. C. Yiu, S. Zhang, W. Zhang, and S.-G. Zhou (DRHBc Mass Table Collaboration), Deformed relativistic Hartree-Bogoliubov theory in continuum with a point-coupling functional: Examples of even-even Nd isotopes, Phys. Rev. C 102, 024314 (2020).
  * Sun [2021] X.-X. Sun, Deformed two-neutron halo in ${}^{19}\mathrm{B}$, Phys. Rev. C 103, 054315 (2021).
  * Sun  _et al._ [2018] X.-X. Sun, J. Zhao, and S.-G. Zhou, Shrunk halo and quenched shell gap at $N=16$ in 22C: Inversion of $sd$ states and deformation effects, Phys. Lett. B 785, 530 (2018).
  * Sun  _et al._ [2020] X.-X. Sun, J. Zhao, and S.-G. Zhou, Study of ground state properties of carbon isotopes with deformed relativistic Hartree-Bogoliubov theory in continuum, Nucl. Phys. A 1003, 122011 (2020).
  * Zhong  _et al._ [2022] S. Y. Zhong, S. S. Zhang, X. X. Sun, and M. S. Smith, Study of the deformed halo nucleus 31Ne with glauber model based on microscopic self-consistent structures, Sci. China Phys. Mech. Astron. 65, 262011 (2022).
  * Pan  _et al._ [2024] C. Pan, K. Zhang, and S. Zhang, Nuclear magnetism in the deformed halo nucleus 31Ne, Phys. Lett. B 855, 138792 (2024).
  * Zhang  _et al._ [2023b] K. Zhang, S. Yang, J. An, S. Zhang, P. Papakonstantinou, M.-H. Mun, Y. Kim, and H. Yan, Missed prediction of the neutron halo in 37Mg, Phys. Lett. B 844, 138112 (2023b).
  * An  _et al._ [2024] J.-L. An, K.-Y. Zhang, Q. Lu, S.-Y. Zhong, and S.-S. Zhang, A unified description of the halo nucleus 37Mg from microscopic structure to reaction observables, Phys. Lett. B 849, 138422 (2024).
  * Zhang  _et al._ [2019] K. Y. Zhang, D. Y. Wang, and S. Q. Zhang, Effects of pairing, continuum, and deformation on particles in the classically forbidden regions for Mg isotopes, Phys. Rev. C 100, 034312 (2019).
  * In  _et al._ [2021] E. J. In, P. Papakonstantinou, Y. Kim, and S.-W. Hong, Neutron drip line in the deformed relativistic Hartree-Bogoliubov theory in continuum: Oxygen to calcium, Int. J. Mod. Phys. E 30, 2150009 (2021).
  * Zhang  _et al._ [2021] K. Zhang, X. He, J. Meng, C. Pan, C. Shen, C. Wang, and S. Zhang, Predictive power for superheavy nuclear mass and possible stability beyond the neutron drip line in deformed relativistic Hartree-Bogoliubov theory in continuum, Phys. Rev. C 104, L021301 (2021).
  * Pan  _et al._ [2021] C. Pan, K. Y. Zhang, P. S. Chong, C. Heo, M. C. Ho, J. Lee, Z. P. Li, W. Sun, C. K. Tam, S. H. Wong, R. W.-Y. Yeung, T. C. Yiu, and S. Q. Zhang, Possible bound nuclei beyond the two-neutron drip line in the $50\leq Z\leq 70$ region, Phys. Rev. C 104, 024331 (2021).
  * He  _et al._ [2021] X.-T. He, C. Wang, K.-Y. Zhang, and C.-W. Shen, Possible existence of bound nuclei beyond neutron drip lines driven by deformation, Chin. Phys. C 45, 101001 (2021).
  * He  _et al._ [2024] X.-T. He, J.-W. Wu, K.-Y. Zhang, and C.-W. Shen, Odd-even differences in the stability peninsula in the $106\leq Z\leq 112$ region with the deformed relativistic Hartree-Bogoliubov theory in continuum, Phys. Rev. C 110, 014301 (2024).
  * Zhang  _et al._ [2022] K. Zhang, M.-K. Cheoun, Y.-B. Choi, P. S. Chong, J. Dong, Z. Dong, X. Du, L. Geng, E. Ha, X.-T. He, C. Heo, M. C. Ho, E. J. In, S. Kim, Y. Kim, C.-H. Lee, J. Lee, H. Li, Z. Li, T. Luo, J. Meng, M.-H. Mun, Z. Niu, C. Pan, P. Papakonstantinou, X. Shang, C. Shen, G. Shen, W. Sun, X.-X. Sun, C. K. Tam, Thaivayongnou, C. Wang, X. Wang, S. H. Wong, J. Wu, X. Wu, X. Xia, Y. Yan, R. W.-Y. Yeung, T. C. Yiu, S. Zhang, W. Zhang, X. Zhang, Q. Zhao, and S.-G. Zhou (DRHBc Mass Table Collaboration), Nuclear mass table in deformed relativistic Hartree-Bogoliubov theory in continuum, I: Even-even nuclei, Atom. Data Nucl. Data Tabl. 144, 101488 (2022).
  * Guo  _et al._ [2024] P. Guo, X. Cao, K. Chen, Z. Chen, M.-K. Cheoun, Y.-B. Choi, P. C. Lam, W. Deng, J. Dong, P. Du, X. Du, K. Duan, X. Fan, W. Gao, L. Geng, E. Ha, X.-T. He, J. Hu, J. Huang, K. Huang, Y. Huang, Z. Huang, K. D. Hyung, H. Y. Chan, X. Jiang, S. Kim, Y. Kim, C.-H. Lee, J. Lee, J. Li, M. Li, Z. Li, Z. Li, Z. Lian, H. Liang, L. Liu, X. Lu, Z.-R. Liu, J. Meng, Z. Meng, M.-H. Mun, Y. Niu, Z. Niu, C. Pan, J. Peng, X. Qu, P. Papakonstantinou, T. Shang, X. Shang, C. Shen, G. Shen, T. Sun, X.-X. Sun, S. Wang, T. Wang, Y. Wang, Y. Wang, J. Wu, L. Wu, X. Wu, X. Xia, H. Xie, J. Yao, K. Y. Ip, T. C. Yiu, J. Yu, Y. Yu, K. Zhang, S. Zhang, S. Zhang, W. Zhang, X. Zhang, Y. Zhang, Y. Zhang, Y. Zhang, Z. Zhang, Q. Zhao, Y. Zhao, R. Zheng, C. Zhou, S.-G. Zhou, and L. Zou (DRHBc Mass Table Collaboration), Nuclear mass table in deformed relativistic Hartree–Bogoliubov theory in continuum, II: Even-Z nuclei, Atom. Data Nucl. Data Tabl. , 101661 (2024).
  * Zhou  _et al._ [2003b] S.-G. Zhou, J. Meng, and P. Ring, Spherical relativistic Hartree theory in a Woods-Saxon basis, Phys. Rev. C 68, 034323 (2003b).
  * Zhang  _et al._ [2022a] K. Y. Zhang, C. Pan, and S. Q. Zhang, Optimized Dirac Woods-Saxon basis for covariant density functional theory, Phys. Rev. C 106, 024302 (2022a).
  * Sun and Zhou [2021a] X.-X. Sun and S.-G. Zhou, Rotating deformed halo nuclei and shape decoupling effects, Sci. Bull. 66, 2072 (2021a).
  * Sun and Zhou [2021b] X.-X. Sun and S.-G. Zhou, Angular momentum projection in the deformed relativistic Hartree-Bogoliubov theory in continuum, Phys. Rev. C 104, 064319 (2021b).
  * Pan  _et al._ [2022] C. Pan, M.-K. Cheoun, Y.-B. Choi, J. Dong, X. Du, X.-H. Fan, W. Gao, L. Geng, E. Ha, X.-T. He, J. Huang, K. Huang, S. Kim, Y. Kim, C.-H. Lee, J. Lee, Z. Li, Z.-R. Liu, Y. Ma, J. Meng, M.-H. Mun, Z. Niu, P. Papakonstantinou, X. Shang, C. Shen, G. Shen, W. Sun, X.-X. Sun, J. Wu, X. Wu, X. Xia, Y. Yan, T. C. Yiu, K. Zhang, S. Zhang, W. Zhang, X. Zhang, Q. Zhao, R. Zheng, and S.-G. Zhou (DRHBc Mass Table Collaboration), Deformed relativistic Hartree-Bogoliubov theory in continuum with a point-coupling functional. II. examples of odd Nd isotopes, Phys. Rev. C 106, 014316 (2022).
  * Zhao  _et al._ [2010] P. W. Zhao, Z. P. Li, J. M. Yao, and J. Meng, New parametrization for the nuclear covariant energy density functional with a point-coupling interaction, Phys. Rev. C 82, 054319 (2010).
  * Uzawa  _et al._ [2021] K. Uzawa, K. Hagino, and K. Yoshida, Role of triaxiality in deformed halo nuclei, Phys. Rev. C 104, L011303 (2021).
  * Zhang  _et al._ [2023c] K. Y. Zhang, S. Q. Zhang, and J. Meng, Possible neutron halo in the triaxial nucleus ${}^{42}\mathrm{Al}$, Phys. Rev. C 108, L041301 (2023c).
  * Bürvenich  _et al._ [2002] T. Bürvenich, D. G. Madland, J. A. Maruhn, and P.-G. Reinhard, Nuclear ground state observables and QCD scaling in a refined relativistic point coupling model, Phys. Rev. C 65, 044308 (2002).
  * Sun  _et al._ [2024] M. Z. Sun, Y. Yu, X. P. Wang, M. Wang, J. G. Li, Y. H. Zhang, K. Blaum, Z. Y. Chen, R. J. Chen, H. Y. Deng, C. Y. Fu, W. W. Ge, W. J. Huang, H. Y. Jiao, H. H. Li, H. F. Li, Y. F. Luo, T. Liao, Y. A. Litvinov, M. Si, P. Shuai, J. Y. Shi, Q. Wang, Y. M. Xing, X. Xu, H. S. Xu, F. R. Xu, Q. Yuan, T. Yamaguchi, X. L. Yan, J. C. Yang, Y. J. Yuan, X. H. Zhou, X. Zhou, M. Zhang, and Q. Zeng, Ground-state mass of 22Al and test of state-of-the-art ab initio calculations, Chin. Phys. C 48, 034002 (2024).


Figure 1.  (top) An Earth-sized planet rendered in real-time using our
triangulation method. (bottom) An alternative wireframe-view of the render as
seen from ground to space through successive zoomed-in insets.

#  Concurrent Binary Trees for Large-Scale Game Components

Anis Benyoub  0009-0007-4609-1728 Intel CorporationFrance and  Jonathan Dupuy
0000-0002-4447-3147 Intel CorporationFrance

###### Abstract.

A concurrent binary tree (CBT) is a GPU-friendly data-structure suitable for
the generation of bisection based terrain tessellations, i.e., adaptive
triangulations over square domains. In this paper, we expand the benefits of
this data-structure in two respects. First, we show how to bring bisection
based tessellations to arbitrary polygon meshes rather than just squares. Our
approach consists of mapping a triangular subdivision primitive, which we
refer to as a bisector, to each halfedge of the input mesh. These bisectors
can then be subdivided adaptively to produce conforming triangulations solely
based on halfedge operators. Second, we alleviate a limitation that restricted
the triangulations to low subdivision levels. We do so by using the CBT as a
memory pool manager rather than an implicit encoding of the triangulation as
done originally. By using a CBT in this way, we concurrently allocate and/or
release bisectors during adaptive subdivision using shared GPU memory. We
demonstrate the benefits of our improvements by rendering planetary scale
geometry out of very coarse meshes. Performance-wise, our triangulation method
evaluates in less than 0.2ms on console-level hardware.

level-of-detail, subdivision, GPU, real-time, rendering

††copyright: acmlicensed††journalyear: 2024††doi: 10.1145/3675371††journal:
PACMCGIT††journalvolume: 7††journalnumber: 3††publicationmonth: 7††ccs:
Computing methodologies Rendering††ccs: Computing methodologies Massively
parallel algorithms

##  1\. Introduction

#### Motivation

Modern game engines provide support for large-scale components such as
terrains, water systems, or planetary globes as shown in Figure 1. Due to
their intrinsic size and resolution, traditional level-of-detail approaches
like Nanite (Karis et al., 2021) are not applicable as the amounts of geometry
involved are simply too large111as an example, storing the fully subdivided
mesh of Figure 1 would require exa-Bytes of data, which is orders away from
what a modern SSD can store. Instead, these large-scale components rely on
more ad-hoc solutions that tend to fail in some respect. For instance:

  * -

clipmaps (Losasso and Hoppe, 2004; Asirvatham and Hoppe, 2005) coupled with
static meshes for large vistas (Epic, 2023) are hard to balance because they
depend on the viewing altitude,

  * -

projected grids (Hinsinger et al., 2002) work well for animated surfaces but
produce artifacts on static geometry during camera flythroughs,

  * -

adaptive grids such as quadtrees are either implemented on the CPU (Etienne,
2023) or limited in resolution (Dupuy, 2020; Deliot et al., 2021).

In this work, we describe an adaptive meshing scheme that is free from the
aforementioned limitations and suitable for managing level-of-detail for the
geometry of these specialized components.

#### Contributions and Outline

Our meshing scheme computes adaptive triangulations on the GPU progressively
through time. As such, it produces optimized amounts of geometry at any time
and from ground to space. In terms of contributions, it represents an
improvement of the concurrent binary tree (CBT) method (Dupuy, 2020) in two
distinct aspects, which we detail in the remainder of this article:

  * •

In Section 2, we describe an algorithm similar to ROAM (Duchaineau et al.,
1997) that produces adaptive triangulations for halfedge meshes rather than
just squares as done in the original CBT paper.

  * •

In Section 3, we describe a parallel implementation of this sequential
algorithm by using a CBT as a memory manager, i.e., in a different way than
suggested in the original CBT paper.

  * •

In Section 4, we validate our approach through various rendering results and
detailed performance measurements.

Thanks to the way we improve, re-use and combine the ROAM and CBT algorithms,
we render planetary surfaces with centimetric detail entirely on mid-range
GPUs and using a single representation. Our source code is available online:
https://github.com/AnisB/large_cbt.

##  2\. Adaptive Triangulation Algorithm

In this section, we describe the adaptive triangulation algorithm that we will
implement in parallel in Section 3. We start by providing some background and
position our algorithm with respect to related work (Section 2.1). Next, we
describe how we initialize our algorithm using halfedge operators (Section
2.2). Finally, we provide each operation necessary to compute adaptive
triangulations progressively through time (Section 2.3).

###  2.1. Background

#### Halfedge Meshes as Input

Our input solely consists of a halfedge mesh. A halfedge mesh (Weiler, 1985;
Kettner, 1999; Botsch et al., 2010) represents a polygon mesh as a set of
vertex points and halfedges where each halfedge is characterized by its
operators Twin, Next, Prev, Vert, Edge, and Face. Our implementation relies on
a generalization of directed edges (Campagna et al., 1998; Dupuy and Vanhoey,
2021), which is illustrated in Figure 2 along with all the aforementioned
halfedge operators.

$f_{0}$

$f_{1}$

$f_{2}$

$e_{0}$

$e_{1}$

$e_{2}$

$e_{3}$

$e_{4}$

$e_{5}$

$e_{6}$

$e_{7}$

$e_{8}$

$h_{0}$

$h_{1}$

$h_{2}$

$h_{3}$

$h_{4}$

$h_{5}$

$h_{6}$

$h_{7}$

$h_{8}$

$h_{9}$

$h_{10}$

$h_{11}$

$v_{0}$

$v_{1}$

$v_{2}$

$v_{3}$

$v_{4}$

$v_{5}$

$v_{6}$

label | content
---|---
$h$ | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11
Twin | 6 | 7 | -1 | -1 | -1 | 8 | 0 | 1 | 5 | -1 | -1 | -1
Next | 1 | 2 | 3 | 0 | 5 | 6 | 4 | 8 | 9 | 10 | 11 | 7
Prev | 3 | 0 | 1 | 2 | 6 | 4 | 5 | 11 | 7 | 8 | 9 | 10
Vert | 3 | 2 | 1 | 0 | 3 | 4 | 2 | 1 | 2 | 4 | 5 | 6
Edge | 3 | 4 | 0 | 1 | 2 | 5 | 3 | 4 | 5 | 6 | 7 | 8
Face | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 2 | 2 | 2 | 2 | 2

Figure 2.  Halfedge mesh representation used for our bisection based
subdivision scheme. The blue and green halfedges are highlighted as
illustrative examples of a regular and border halfedge, respectively.

halfedge mesh (input)

$h_{0}$

$h_{1}$

$h_{2}$

$h_{3}$

$h_{4}$

$h_{5}$

$h_{6}$

$h_{7}$

$h_{8}$

$h_{9}$

$h_{10}$

$h_{11}$

(a)

root bisectors

$b_{0}^{0}$

$b_{1}^{0}$

$b_{2}^{0}$

$b_{3}^{0}$

$b_{4}^{0}$

$b_{5}^{0}$

$b_{6}^{0}$

$b_{7}^{0}$

$b_{8}^{0}$

$b_{9}^{0}$

$b_{10}^{0}$

$b_{11}^{0}$

(b)

adaptive bisection

$b_{0}^{0}$

$b_{92}^{3}$

$b_{2}^{0}$

$b_{3}^{0}$

$b_{4}^{0}$

$b_{5}^{0}$

$b_{6}^{0}$

$b_{20}^{1}$

$b_{8}^{0}$

$b_{9}^{0}$

$b_{44}^{2}$

$b_{28}^{2}$

$b_{93}^{3}$

$b_{15}^{1}$

$b_{2}^{1}$

$b_{3}^{1}$

$b_{29}^{2}$

$b_{47}^{2}$

$b_{42}^{2}$

$b_{43}^{2}$

$b_{90}^{3}$

$b_{91}^{3}$

(c)

Figure 3.  Overview of our triangulation method.

$b_{0}^{0}$

$b_{2}^{0}$

$b_{3}^{0}$

$b_{4}^{0}$

$b_{5}^{0}$

$b_{6}^{0}$

$b_{8}^{0}$

$b_{9}^{0}$

$b_{10}^{0}$

$b_{11}^{0}$

$b_{14}^{1}$

$b_{15}^{1}$

$b_{2}^{1}$

$b_{3}^{1}$

(a)

$b_{0}^{0}$

$b_{22}^{1}$

$b_{2}^{0}$

$b_{3}^{0}$

$b_{4}^{0}$

$b_{5}^{0}$

$b_{6}^{0}$

$b_{23}^{1}$

$b_{8}^{0}$

$b_{9}^{0}$

$b_{10}^{0}$

$b_{14}^{1}$

$b_{15}^{1}$

$b_{2}^{1}$

$b_{3}^{1}$

(b)

$b_{0}^{0}$

$b_{22}^{1}$

$b_{2}^{0}$

$b_{3}^{0}$

$b_{4}^{0}$

$b_{5}^{0}$

$b_{6}^{0}$

$b_{8}^{0}$

$b_{9}^{0}$

$b_{10}^{0}$

$b_{28}^{2}$

$b_{15}^{1}$

$b_{2}^{1}$

$b_{3}^{1}$

$b_{29}^{2}$

$b_{46}^{2}$

$b_{47}^{2}$

(c)

Figure 4.  Refinement over the compatibility chain of bisector $b_{14}^{1}$
(highlighted in orange).

#### Bisection Based Triangulation

Our triangulation algorithm is illustrated in Figure 3 and consists in
bisecting triangles along one of their edges. Triangle bisection arises
frequently in the scientific literature, though under different names.
Possible names include, e.g., bisection refinement (Maubach, 1995), triangle
bintrees (Duchaineau et al., 1997), 4-8 refinement (Velho, 2000; Velho and
Zorin, 2001), diamonds (Hwa et al., 2004; Weiss and De Floriani, 2011; Weiss,
2011; Yalçın et al., 2011), right-triangulated irregular networks (Lindstrom
et al., 1996; Evans et al., 2001), hierarchical simplicial meshes (Atalay and
Mount, 2007), newest vertex bisection (Mitchell, 2016), and finally longest-
edge bisection (Rivara, 1984; Özturan, 1996; Lindstrom and Pascucci, 2002).
The main difficulty with triangle bisection is that it is known to be NP-hard
to initialize on arbitrary meshes (Mitchell, 2016). Our contribution in this
particular area is to show that the halfedges of the input mesh provide an
intrinsic triangulation that provides a valid initialization. This has two
benefits. First, it results in an extremely simple algorithm. Second, it
preserves the topology of the input mesh (as opposed to existing methods,
e.g., (Velho and Zorin, 2001)), making it more suitable for animated assets.
Aside from our original initialization method, the logic of the algorithm as
described in this section is very similar to the ROAM method (Duchaineau et
al., 1997).

###  2.2. Initialization: Root Bisectors as Halfedges

We initialize root bisectors at the surface of an input halfedge mesh as shown
in Figure 3 (a, b). The properties of these root bisectors are
straightforward:

#### A Bisector for Each Halfedge

Each halfedge maps to exactly one root bisector. For instance, the halfedge
$h_{7}$ in Figure 3 (a) maps to the root bisector $b_{7}^{0}$ in Figure 3 (b).
Note that we refer to a bisector using the notation $b_{j}^{d}$, where $d\geq
0$ denotes its subdivision level and $j\geq 0$ its index.

#### Root Bisector Vertices

We retrieve the vertices of each bisectors thanks to the halfedge operators
Next and Prev. For instance, the vertices of the root bisector $b_{7}^{0}$ in
Figure 3 (b) are

$\displaystyle\text{the vertex }v_{0}$ $\displaystyle:=\textsc{Vert}(h_{7}),$
$\displaystyle\text{the vertex }v_{1}$
$\displaystyle:=\textsc{Vert}(\textsc{Next}(h_{7}))=\textsc{Vert}(h_{8}),$
$\displaystyle\text{and the average }v_{2}$
$\displaystyle:=\frac{1}{5}\left(\textsc{Vert}(h_{7})+\textsc{Vert}(h_{8})+\cdots+\textsc{Vert}(h_{11})\right).$

Algorithm 1 provides pseudocode for computing these vertices.

1:function RootBisectorVertices(halfedgeID: integer)

2: nextID $\leftarrow$ Next(halfedgeID)

3: $v_{0}$ $\leftarrow$ Vert(halfedgeID)

4: $v_{1}$ $\leftarrow$ Vert(nextID)

5: $v_{2}$ $\leftarrow$ $v_{0}$

6: $n$ $\leftarrow$ 1

7: $h$ $\leftarrow$ nextID

8: while $h$ $\neq$ halfedgeID do

9: $v_{2}$ $\leftarrow$ $v_{2}$ $+$ Vert($h$)

10: $n$ $\leftarrow$ $n+1$

11: $h$ $\leftarrow$ Next($h$)

12: end while

13: $v_{2}$ $\leftarrow$ $v_{2}/n$

14: return $\left[v_{0},\,v_{1},\,v_{2}\right]^{T}$

15:end function

Algorithm 1 Root Bisector Vertices

1:function BisectorVertices($b_{j}^{d}$: bisector)

2: halfedgeID $\leftarrow$ $j/2^{d}$ $\triangleright$ root bisector index

3: $M\leftarrow I$ $\triangleright$ identity init.

4: $h\leftarrow j$

5: while $h\neq$ halfedgeID do $\triangleright$ compute subd. matrix

6: $b\leftarrow$ BitwiseAnd($h$ , 1)

7: $M\leftarrow M\times M_{b}$ $\triangleright$ see Eq. (1)

8: $h\leftarrow h/2$

9: end while

10: return $M\,\times$ RootBisectorVertices(halfedgeID)

11:end function

Algorithm 2 Bisector Vertices

#### Neighboring Bisectors

We retrieve neighboring bisectors thanks to the halfedge operators Next, Prev,
and Twin. For instance, the bisectors adjacent to the bisector $b_{7}^{0}$ in
Figure 3 (b) are

$\displaystyle\textsc{Next}(h_{7})=h_{8}$ $\displaystyle\mapsto b^{0}_{8},$
$\displaystyle\textsc{Prev}(h_{7})=h_{11}$ $\displaystyle\mapsto b^{0}_{11},$
$\displaystyle\textsc{Twin}(h_{7})=h_{1}$ $\displaystyle\mapsto b^{0}_{1}.$

###  2.3. Progressive Subdivision Operators

In the following paragraphs, we provide two key operations, namely:

  1. (1)

bisector _refinement_ , which increases the resolution of the mesh, and

  2. (2)

bisector _decimation_ , which conversely decreases the resolution of the mesh.

A key property of these operations is that they guarantee conforming
topologies at any given time when applied locally (as opposed to globally).
Furthermore, they allow for ”incremental updates” of an existing triangulation
(typically the one from the previous frame) into a slightly more appropriate
one in the spirit of ROAM (Duchaineau et al., 1997). This is done by iterating
over existing bisectors and deciding whether to refine, decimate or leave each
one of them as is. The key benefit of incremental updates is that they provide
an alternative to computing entire triangulations in either bottom-up or top-
down fashion. This is particularly important for large-scale game components
as they require large subdivision depths.

#### Notation

Refining a bisector $b_{j}^{d}$ splits it into two new ones. We denote these
new bisectors as

$\displaystyle b_{j}^{d}$ $\displaystyle\mapsto b_{2j}^{d+1}\qquad$ (first
child) $\displaystyle\mapsto b_{2j+1}^{d+1}\qquad$ $\displaystyle\text{(second
child)}.$

In Figure 4 for instance, the bisector $b_{14}^{1}$ shown in inset (b) splits
into the bisectors $b_{28}^{2}$ and $b_{29}^{2}$ shown in inset (c). The
reason why we index the children in this way is because we can retrieve their
vertices straightforwardly through its subdivision matrix as we show next.

#### Bisector Vertices via its Subdivision Matrix

The bisector refinement rule consists in splitting the bisector into two new
ones according to the following refinement matrices (note the difference
between the first two rows):

(1) $M_{0}=\begin{bmatrix}1&0&0\\\ 0&0&1\\\ \frac{1}{2}&\frac{1}{2}&0\\\
\end{bmatrix},\quad\textrm{and}\quad M_{1}=\begin{bmatrix}0&0&1\\\ 0&1&0\\\
\frac{1}{2}&\frac{1}{2}&0\\\ \end{bmatrix}.$

Based on the way we index our bisectors, we retrieve the subdivision matrix
associated with any bisector as shown in lines (3–9) of Algorithm 2. In order
to get the vertices we simply multiply this matrix by the vertices of the root
bisector as shown in line (10) of Algorithm 2.

#### Bisector Refinement

We implement the newest vertex bisection algorithm (Mitchell, 2016), which we
provide in Algorithm 3. This algorithm ensures that the triangulations
produced by the refinement of any bisector results in a conforming
triangulation. This is done by propagating the refinement operation through a
so-called compatibility chain, which is unique and determined through the
recursive calls in Algorithm 3. We illustrate a practical example of such a
propagation in Figure 4 for the bisection of the bisector $b_{14}^{1}$ shown
in orange. In order to make this propagation work, each bisector must have
pointers to its direct neighbors, and we discuss next how we implement this.

1:procedure Refine($b_{j}$: bisector)

2: $b_{k}$ $\leftarrow$ Twin($b_{j}$)

3: if $b_{k}$ $\neq$ null then

4: if Twin($b_{k}$) $\neq$ $b_{j}$ then

5: Refine($b_{k}$)

6: end if

7: Split($b_{j}$, $b_{k}$) $\triangleright$ non-boundary

8: else

9: Split($b_{j}$) $\triangleright$ boundary

10: end if

11:end procedure

Algorithm 3 Adaptive Refinement

1:procedure Decimate($b_{j_{1}}$: bisector)

2: bitValue $\leftarrow$ BitwiseAnd($j_{1}$, 1)

3: $b_{j_{2}}$ $\leftarrow$ bitValue ? Prev($b_{j_{1}}$) : Next($b_{j_{1}}$)

4: $b_{j_{3}}$ $\leftarrow$ bitValue ? Next($b_{j_{1}}$) : Prev($b_{j_{1}}$)

5: if $\lfloor\frac{j_{1}}{2}\rfloor$ $=$ $\lfloor\frac{j_{2}}{2}\rfloor$ then

6: if $b_{j_{3}}$ $=$ null then

7: Merge($b_{j_{1}}$, $b_{j_{2}}$) $\triangleright$ boundary

8: else if $\lfloor\log_{2}{j_{1}}\rfloor$ $=$ $\lfloor\log_{2}{j_{3}}\rfloor$
then

9: $b_{j_{4}}$ $\leftarrow$ bitValue ? Next($b_{j_{3}}$) : Prev($b_{j_{3}}$)

10: if $\lfloor\frac{j_{3}}{2}\rfloor$ $=$ $\lfloor\frac{j_{4}}{2}\rfloor$
then

11: Merge($b_{j_{1}}$, $b_{j_{2}}$, $b_{j_{3}}$, $b_{j_{4}}$) $\triangleright$
non-boundary

12: end if

13: end if

14: end if

15:end procedure

Algorithm 4 Conservative Decimation

1:procedure RefinePointers($b_{j}^{d}$)

2: next $\leftarrow$ Next($b_{j}^{d}$)

3: prev $\leftarrow$ Prev($b_{j}^{d}$)

4: if Prev(next) $=$ $b_{j}^{d}$ then

5: Prev(next) $\leftarrow b_{2j+1}^{d+1}$

6: else

7: Twin(next) $\leftarrow b_{2j+1}^{d+1}$

8: end if

9: if Next(prev) $=$ $b_{j}^{d}$ then

10: Next(prev) $\leftarrow b_{2j}^{d+1}$

11: else

12: Twin(prev) $\leftarrow b_{2j}^{d+1}$

13: end if

14:end procedure

Algorithm 5 Pointer Refinement

1:procedure DecimatePointers($b_{2j}^{d+1},b_{2j+1}^{d+1}$)

2: next $\leftarrow$ Twin($b_{2j+1}^{d+1}$)

3: prev $\leftarrow$ Twin($b_{2j}^{d+1}$)

4: if Prev(next) $=$ $b_{2j+1}^{d+1}$ then

5: Prev(next) $\leftarrow b_{j}^{d}$

6: else

7: Twin(next) $\leftarrow b_{j}^{d}$

8: end if

9: if Next(prev) $=$ $b_{2j}^{d+1}$ then

10: Next(prev) $\leftarrow b_{j}^{d}$

11: else

12: Twin(prev) $\leftarrow b_{j}^{d}$

13: end if

14:end procedure

Algorithm 6 Pointer Decimation children of $b_{j}^{d}$ |  children of $b_{k}^{d}$ (if and only if $b_{k}^{d}\neq\text{null}$)
---|---
$\begin{aligned} \textsc{Next}(b_{j}^{d})\mapsto&\,\textsc{Next}(b_{2j}^{d+1})=\;b_{2j+1}^{d+1}\\\ \mapsto&\,\textsc{Next}(b_{2j+1}^{d+1})=\begin{cases}b_{2k}^{d+1}&\text{if $b_{k}^{d}\neq\text{null}$,}\\\ \textrm{null}&\text{otherwise.}\end{cases}\end{aligned}$ | $\begin{aligned} \textsc{Next}(b_{k}^{d})\mapsto&\,\textsc{Next}(b_{2k}^{d+1})=b_{2k+1}^{d+1}\\\ \mapsto&\,\textsc{Next}(b_{2k+1}^{d+1})=b_{2j}^{d+1}\end{aligned}$
$\begin{aligned} \textsc{Prev}(b_{j}^{d})\mapsto&\,\textsc{Prev}(b_{2j}^{d+1})=\begin{cases}b_{2k+1}^{d+1}&\text{if $b_{k}^{d}\neq\text{null}$,}\\\ \textrm{null}&\text{otherwise.}\end{cases}\\\ \mapsto&\,\textsc{Prev}(b_{2j+1}^{d+1})=\;b_{2j}^{d+1}\end{aligned}$ | $\begin{aligned} \textsc{Prev}(b_{k}^{d})\mapsto&\,\textsc{Prev}(b_{2k}^{d+1})=b_{2j+1}^{d+1}\\\ \mapsto&\,\textsc{Prev}(b_{2k+1}^{d+1})=b_{2k}^{d+1}\end{aligned}$
$\begin{aligned} \textsc{Twin}(b_{j}^{d})\mapsto&\,\textsc{Twin}(b_{2j}^{d+1})=\textsc{Prev}(b_{j}^{d})\\\ \mapsto&\,\textsc{Twin}(b_{2j+1}^{d+1})=\textsc{Next}(b_{j}^{d})\end{aligned}$ | $\begin{aligned} \textsc{Twin}(b_{k}^{d})\mapsto&\,\textsc{Twin}(b_{2k}^{d+1})=\textsc{Prev}(b_{k}^{d})\\\ \mapsto&\,\textsc{Twin}(b_{2k+1}^{d+1})=\textsc{Next}(b_{k}^{d})\end{aligned}$
Table 1. Refinement rules for bisector’s neighborhood operators.

#### Neighbor Refinement Rule

Bisector refinement operates either:

  1. (1)

in isolation at a boundary as shown in Figure 4 (b),

  2. (2)

in pairs of same subdivision level as shown in Figure 4 (c).

Let $b_{j}^{d}$ and $b_{k}^{d}=\textsc{Twin}(b_{j}^{d})$ denote the bisectors
forming such a pair. If $b_{j}^{d}$ is located at a boundary, we have
$b_{k}^{d}=\text{null}$. The neighbors of the children of $b_{j}^{d}$ and
$b_{k}^{d}$ are given by the rules compiled in Table 1. Note that when a
bisector is refined, its neighbors must also be updated to reference the newly
created bisectors according to the rules of Algorithm 5.

#### Bisector Decimation

Decimation is the reverse operation of refinement and we could simply
implement it as such. In practice though, we rely on a more conservative
approach, which avoids the ambiguous case where we decimate entire
compatibility chains that carry bisectors under refinement. Our approach thus
only halves the number of bisectors in the two following configurations:

  1. (1)

we decimate four bisectors of same subdivision depth forming a cycle via their
Next and Prev operators into two coarser ones; in Figure 4 for instance, we
decimate the four bisectors $b_{28}^{2}$, $b_{29}^{2}$, $b_{46}^{2}$ and
$b_{47}^{2}$ shown in inset (c) into $b_{14}^{1}$ and $b_{23}^{1}$ shown in
inset (b).

  2. (2)

we decimate two border bisectors of same subdivision depth having their Twin
point to the null bisector (because of the border) into a single one; in
Figure 4 for instance, we decimate the bisectors $b_{22}^{1}$ and $b_{23}^{1}$
shown in inset (b) into $b_{11}^{0}$ shown in inset (a).

The resulting logic is shown in Algorithm 4. Note that when a bisector is
decimated, its neighbors must also be updated to reference the newly created
bisector accoring to the rules of Algorithm 6.

##  3\. GPU Implementation using a CBT

We wish to parallelize the triangulation method from Section 2 over the
bisectors already present in the triangulation. As such, each bisector should
be able to concurrently refine (see Algorithm 3), decimate (see Algorithm 4),
or leave itself untouched. In addition, each bisector should concurrently
update neighbor pointer information (see Algorithms 5, 6). In this section, we
show how to use a concurrent binary tree (CBT) to fulfill these requirements.
We start by recalling details about the CBT data-structure (Section 3.1). We
then show how we use CBTs as a memory pool manager and thread scheduler
(Section 3.2). Finally, we provide implementation details (Section 3.3).

###  3.1. Background

#### Positioning

CBTs were introduced along with a set of algorithms to compute binary
subdivisions over square domains (Dupuy, 2020). As such, we could have re-used
these algorithms for the bisector-based scheme from Section 2. Unfortunately
though, the original implementation links the maximum subdivision depth of the
binary subdivision to that of the CBT. In practice, this restricts the
algorithm to subdivisions that are way below what is required for planetary
scale rendering (note that we further discuss this issue in Section 4). So
rather than re-using the CBT data-structure as is, we modify it so that it can
manage a memory pool of bisectors. The memory pool approach is especially
relevant for our needs as our bisectors require the same amount of data
independently from their subdivision depth. Hence, aside from the memory
layout of the CBT, which we recall next, we revisit its usage/implementation
entirely as a memory manager.

#### Concurrent Binary Tree Data-Structure

Figure 5 (left) shows an example of a CBT of depth $D=4$. A CBT (Dupuy, 2020)
is a full binary tree where:

  * -

the leaf nodes store binary values and form a bitfield,

  * -

the remaining nodes form a sum-reduction tree over these binary values.

Note that, by construction, the root node of a CBT stores the number of bits
set to one in the bitfield.

#### Data-Layout

We store a CBT as a binary heap, i.e., an array of size $2^{D+1}$ as shown in
Figure 5 (right). This leads to the following properties:

  * -

the children of the node indexed by $k\geq 1$ are located at indexes $2k$ and
$2k+1$,

  * -

the parent of the node indexed by $k\geq 1$ is located at index $k/2$.

This layout avoids the need to store explicit pointers to parent and children
within each nodes as they can be computed analytically.

$+$

7

$+$

$+$

2

5

$+$

$+$

$+$

$+$

2

0

2

3

$+$

$+$

$+$

$+$

$+$

$+$

$+$

$+$

1

1

0

0

0

2

2

1

1

0

0

1

0

0

0

0

0

0

1

1

1

1

1

0

CBT data:

bitfield

sum-reduction tree

$+$

1

$+$

$+$

2

3

$+$

$+$

$+$

$+$

4

5

6

7

$+$

$+$

$+$

$+$

$+$

$+$

$+$

$+$

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

array layout:

Figure 5.  The CBT’s (left) data-structure and (right) contiguous memory
layout within an array.

###  3.2. CBT as a Memory Manager

We now provide all the operations required to use a CBT as a memory pool
manager. Note that we describe these operations in a generic fashion since
they are not tied to our triangulation algorithm (we defer specializations for
our triangulation algorithm to the next subsection).

#### Initialization

We allocate a CBT of depth $D\geq 1$ that we use in tandem with a memory pool
of capacity $2^{D}$, i.e., an array of $2^{D}$ constant-sized memory blocks.
These memory blocks must be sized in advance and cannot be re-sized
dynamically. In order to track which blocks within the memory pool are
available, we pair the $i$-th bit from the CBT’s bitfield to the $i$-th block
in the memory pool. We thus have a bit value associated to each memory block.
By convention, we set bits to one when a block is allocated, and zero when
freed/available. Thanks to the CBT’s sum-reduction tree, we know how many
blocks are allocated by reading the root node. In addition, the CBT’s sum-
reduction tree allows scheduling a thread to read from a valid memory block
using the following binary search algorithms.

#### Binary Search Algorithm

Given a CBT of depth $D$, we retrieve the index of the $i$-th bit set to one
in $O(D)$ as shown in Algorithm 7. For the CBT of Figure 5 for instance, this
algorithm returns:

  * -

index 0 for the first bit,

  * -

index 3 for the second bit,

  * -

index 10 for the third bit,

  * -

etc.

Note that, by duality, it is also possible to retrieve the $i$-th bit set to
zero with the same complexity, see Algorithm 8. This dual algorithm is
important to track available memory blocks.

1:function OneToBitID(index: int)

2: bitID $\leftarrow 1$

3: while bitID ¡ $2^{D}$ do

4: bitID $\leftarrow$ 2 $\times$ bitID

5: if index $\geq$ CBT[bitID] then

6: index $\leftarrow$ index $-$ CBT[bitID]

7: bitID $\leftarrow$ bitID $+$ 1

8: end if

9: end while

10: return bitID - $2^{D}$

11:end function

Algorithm 7 Find the $i$-th bit set to one

1:function ZeroToBitID(index: int)

2: bitID $\leftarrow 1$

3: $c\leftarrow 2^{D-1}$

4: while bitID ¡ $2^{D}$ do

5: bitID $\leftarrow$ 2 $\times$ bitID

6: if index $\geq$ ($c-$CBT[bitID]) then

7: index $\leftarrow$ index $-$ ($c-$CBT[bitID])

8: bitID $\leftarrow$ bitID $+$ 1

9: end if

10: $c\leftarrow c/2$

11: end while

12: return bitID - $2^{D}$

13:end function

Algorithm 8 Find the $i$-th bit set to zero

#### Usage

We update the memory pool in parallel through a two-step approach as shown in
Algorithm 9. During the first step (see lines 2–16), we iterate over each
valid memory block and allow for allocation and de-allocation operations. We
detail this step a bit further in the next paragraph. Once this step
completed, we simply launch a sum reduction over the CBT’s updated bitfield.
This completes the update process.

#### Block Iteration and Updates

We parallelize block iteration by scheduling a thread for each memory block.
Each thread loads its associated memory block using Algorithm 7. Whenever a
thread requests a new memory block, we proceed in the following steps:

  1. (1)

we atomically increment an allocation counter that keeps track of the number
of allocations,

  2. (2)

the original value of this counter tells us which 0-valued bit in the CBT’s
bitfield should be set to one thanks to Algorithm 8,

  3. (3)

once this bit is located, we set it to one and write data to the associated
memory block.

As for the case when the thread requests to erase its associated memory block,
we simply set the associated bit to zero within the bitfield. After the sum
reduction is computed at the end of the update, we will be able to overwrite
it safely.

1:procedure ProcessMemory(cbt, pool)

2: counter $\leftarrow 0$

3: blockCount $\leftarrow$ cbt[1]

4: for all threadID $\in$ $[$0, blockCount$)$ do

5: blockID $\leftarrow$ OneToBitID(cbt, threadID)

6: $\cdots$

7: while mallocRequired do

8: mallocID $\leftarrow$ AtomicAdd(counter, 1)

9: newBlockID $\leftarrow$ ZeroToBitID(cbt, mallocID)

10: SetBit(cbt, newBlockID, 1)

11: SetBlock(pool, newBlockID, newData)

12: end while

13: $\cdots$

14: if freeRequired then

15: SetBit(cbt, blockID, 0)

16: end if

17: end for

18: UpdateSumReductionTree(cbt)

19:end procedure

Algorithm 9 Typical memory pool update using a CBT

###  3.3. GPU Triangulation Pipeline

We provide here implementation details of our CBT-based GPU triangulation
algorithm. The objective of this section is two-fold. First, to provide the
necessary details suitable for reproducing our implementation. Second, to
convince the reader that our parallel implementation is viable.

attribute name | type | element size
---|---|---
(input) halfedge buffer | array |  $\times 6$ integer
(input) vertex buffer | array |  $\times 3$ floats
bisector pool |  $2^{D}$ array |  $\times 9$ integers
CBT |  $2^{D+1}$ array |  $\times 1$ integer
allocation counter | scalar |  $\times 1$ integer
pointer buffer |  $2^{D}$ array |  $\times 2$ integers
Table 2. Memory requirements for our implementation.

#### Memory Requirements

We list all our memory requirements in Table 2. Given a halfedge mesh such as
the one shown in Figure 2, we allocate a CBT of depth $D$. The depth $D$ must
be large enough to hold all the bisectors of the mesh, i.e., we must have
$D\geq\lceil\log_{2}(H)\rceil$, where $H\geq 3$ denotes the number of
halfedges of the input mesh. In Figure 2 for instance, we have $H=12$ so we
must have $D\geq 4$. Note that we typically use $D\in[16,19]$ in our
implementation. This CBT manages a memory pool of capacity $2^{D}$ bisectors
in the spirit of what we described in Section 3.2. We store the following data
for each bisector within the memory pool:

  * -

($\times 3$) integers that act as pointers within the memory pool for the
neighbors Next, Prev, and Twin of each bisector,

  * -

($\times 1$) integer for the bisector index, i.e., the value $j$ that is
required to decode the vertices of the bisector as shown in Algorithm 2.

Note that the width of these integer is important: the neighbor pointers must
be sufficiently large to address the entire pool, while the bisector index
enforces a maximum subdivision depth. In our implementation, we use 32-bit
integers for the neighbor pointers and a 64-bit integer for the bisector
index. In addition to these two attributes, we also require data to
concurrently split and/or merge each bisector. We store the following
additional data for each bisector:

  * -

($\times 1$) integer that encodes a split/merge command as a bit code, which
we modify concurrently via atomic bitwise-ORs,

  * -

($\times 4$) integers that store unused memory pool locations where the
bisector can write to.

The former integer allows us to make sure splits and/or merges are only
evaluated once per bisector. The latter ones are sized based on the fact that
we only allow one refinement and/or decimation level per bisector during each
incremental update. This means that in the worst case, a bisector will split
into four new ones (hence four integers). Such a case happens whenever the
bisector belongs to the compatibility chain of two foreign bisectors under
refinement. In Figure 4 for instance, splitting bisector $b_{14}^{1}$ results
in splitting $b_{11}^{0}$ into three new ones due to its location in
$b_{14}^{1}$’s compatibility chain. Finally, we further allocate memory for
the following:

  * -

an atomic counter, i.e., an integer, that we increment for each memory
allocation,

  * -

a $2^{D}$ buffer of ($\times 2$) integers per element, which caches the
results of Algorithms 7 and 8.

We further detail the purpose of each of these attributes in the following
paragraphs.

#### Initialization

We initialize the memory pool with $H$ root bisectors, where we recall that
$H\geq 3$ denotes the number of halfedges of the input mesh. We place these
bisectors at the first $H$ blocks of the memory pool and set the first $H$ bit
of the CBT’s bitfield to one (the rest are set to zero). In the memory pool,
we uniquely index each bisector as

$\texttt{bisector.index}=\lceil\log_{2}H\rceil+h,$

where $h\in[0,H-1]$ denotes the index of the mesh’s halfedge. As for the
neighbors, we simply copy the values of the halfedge buffer

bisector.next $\displaystyle=\textsc{Next}(h)$ bisector.prev
$\displaystyle=\textsc{Prev}(h)$ bisector.twin
$\displaystyle=\textsc{Twin}(h).$

We then compute the sum-reduction tree of the CBT to complete the
initialization. The rest of the memory is used during our incremental updates,
which we describe next.

allocation counter

[RW]

Dispatch(1)

(1) ResetCounter

CBT

[RO]

pointer buffer

[RW]

DispatchIndirect()

(2) CachePointers

pointer buffer

[RO]

bisector pool

[RW]

DispatchIndirect()

(3) ResetCommands

pointer buffer

[RO]

bisector pool

[RW]

allocation counter

[RW]

DispatchIndirect()

(4) GenerateCommands

pointer buffer

[RO]

bisector pool

[RW]

allocation counter

[RW]

DispatchIndirect()

(5) ReserveBlocks

pointer buffer

[RO]

bisector pool

[RW]

DispatchIndirect()

(6) FillNewBlocks

pointer buffer

[RO]

bisector pool

[RW]

DispatchIndirect()

(7) UpdateNeighbors

CBT

[RW]

pointer buffer

[RO]

bisector pool

[RW]

DispatchIndirect()

(8) UpdateBitfield

CBT

[RW]

for each $d$ in [$0,\;D-1$]

Dispatch($2^{D-1-d}$)

(9) SumReduction

Figure 6.  GPU update loop for our adaptive triangulation algorithm. Memory,
CPU commands and GPU kernels are respectively shown in green, gray and red.
Each kernel is implicitely followed by a GPU memory barrier.

#### Incremental Update Pipeline

We update the triangulation incrementally. Each incremental update consists in
iterating over each bisector in parallel. In turn, these bisectors can either
be refined or decimated once. In our experiments, this approach is enough to
handle planetary scales in realtime as we showcase in Section 4. Our GPU
update routine is illustrated in Figure 6 and consists of 9 shader kernels,
which we detail below:

####  _(1)_ ResetCounter

We simply set the allocation counter to zero. We use this counter to track the
number of allocations we need to make to update our triangulation. Note that
this kernel requires a single thread invocation, while all subsequent ones
require one thread per bisector, whose number we retrieve from the root
element of the CBT.

####  _(2)_ CachePointers

We store the result of Algorithm 7 in the first integer of the pointer buffer.
This allows us to precompute the index buffer of bisectors located in the
memory pool, which we use at the beginning of every subsequent kernel to load
the data associated with each bisector (i.e., we use bisector =
MemoryPool[PointerBuffer[threadID]]). We also store the result of Algorithm 8
in the second integer of the pointer buffer. This precomputes the index buffer
of the available blocks in the memory pool, which we use for allocations.

####  _(3)_ ResetCommands

We set the command of each bisector to zero.

####  _(4)_ GenerateCommands

Here we decide whether each bisector should be refined, decimated or kept as
is. In our applications, we make our decision by decompressing the vertices of
the bisector via Algorithm 2 and making sure its screen-space area matches a
user-defined value. We record the decision in the command integer using atomic
bitwise-OR operations (by doing so we issue every possible split and merge
command only once). We modify the command depending on the decision:

  * -

In case of refinement, we mimic Algorithm 3 by scattering a split command for
the active bisector as well as those that belong to the compatibility chain.
For the bisectors that belong to the compatibility chain, we need to track
which edge of the bisector must be bisected. This is trivial to do thanks to
the neighbor operators. Since there are only 3 neighbors per bisector, we
reserve 3-bits for the refinement command, each bit corresponding to an edge
of the bisector. Note that we condition the execution of this algorithm to the
amount of memory available in the CBT. To do so, we atomically increment the
allocation counter by the maximum number of allocations. This number depends
on the subdivision depth $d$ of the bisector and satisfies

$\texttt{maxAllocation}=3d+4.$

Thus we only execute the refinement algorithm if the CBT has enough available
bits to allocate such a number. In case of overflow, we atomically decrement
the allocation counter by the same number and skip refinement for this
specific bisector.

  * -

In case of decimation, we mimic Algorithm 4 by first making sure that the
bisector belongs to a configuration that can be merged. If it does, we write a
merge command to the active bisector. Our merge command records the merge
configuration (either triangle or quad as described in Section 2.3) and a flag
that tags whether the bisector has the smallest index of the configuration.
The latter bit is important to ensure we allocate for the root bisectors only
once later in the pipeline. We therefore reserve 3-bits (different from those
used for refinement) for the merge command as well. Just as in the case of
refinement, we condition the execution of our merge algorithm to the space
left in the CBT. Since decimation results in a maximum of two allocations, we
increment the allocation counter by two and proceed similarly to the
refinement step.

  * -

Finally, if we decide to keep the bisector as is, we leave the command
untouched.

At the end of this step, each bisector has a specific command and the
allocation counter gives us the number of allocations we have to perform in
the CBT.

####  _(5)_ ReserveBlocks

We write to the 4 integers we allocated per bisector to store unused memory
pool locations. For each bisector, we read its associated command and
determine how many allocations it must make in the memory pool. Due to the way
we generate the commands in the previous kernel, a bisector may request splits
(at most 4) and/or a merge. When both are required (this happens when a
bisector decides to merge and belongs to the compatibility chain of another
bisector that requests a split), we ignore the merge command and only apply
splits. We then atomically decrement the allocation counter by the number of
allocations nAlloc required by the bisector, and save the memory locations
cached in the pointer buffer in the range [counter, counter + nAlloc \- 1]. In
the case of a merge, only the bisector tagged with the minimum index performs
allocations. Such allocations are conditioned to the fact that all relevant
bisectors must agree to merge together, i.e., their command must exclusively
request a merge. At the end of this step, each bisector has a unique set of
memory pool locations where it can safely write new data.

####  _(6)_ FillNewBlocks

Here each bisector writes data to the memory blocks it has allocated.
Specifically, we compute and save the index of each newly created bisector. In
addition, we set the pointers that inherit from the active bisector according
to Table 1. At the end of this step, all bisectors have a valid index and a
partial number of valid pointers to their neighbors. We update the remaining
pointers in the next step.

####  _(7)_ UpdateNeighbors

Each bisector scatters data to its neighbors. This step is necessary for the
data produced by the active bisector’s neighbors to properly reference the
data produced by the active bisector. Depending on the command, we apply the
rules (or compositions of these rules in the case where more than 2 splits are
required) of Algorithm 5 and Algorithm 6. At the end of this step, all the
bisectors have valid pointers to their neighbors.

####  _(8)_ UpdateBitfield

We update the bitfield of the CBT. Any bisector that has a non-null command
must be freed so we set their associated bit to zero. Depending on the
command, we set up to 4 bits to one to save the allocations triggered by the
bisector.

####  _(9)_ SumReduction

We update the sum-reduction tree of the CBT. After this kernel, we know how
many memory blocks are used and, conversely, free in the memory pool. We can
thus trigger a new round of incremental update to further refine and/or
decimate our input geometry.

##  4\. Evaluation and Discussion

In this section, we validate our method and compare its performances against
alternative ones.

###  4.1. Test Scenes

#### Water Systems

In Figure 1, we show a water-system running on top of an Earth-sized planet
(i.e., roughly 510 million square kilometers) rendered using our triangulation
method. We also show a wireframe view segmented as eight successive insets;
notice the scale covered by our triangulation and how it adapts to the
camera’s view frustum to produce equally-sized triangle in screen-space. The
planet’s base mesh is a regular dodecahedron, which consists of 12 pentagonal
faces thus leading to $12\times 5=60$ halfedges and root bisectors. We refine
this base mesh over camera-visible areas so that each triangle occupies
roughly 49 pixels on-screen. During refinement, we project the triangles’
vertices on the surface of a sphere, and further displace them using four
layers of choppy waves (Tessendorf et al., 2001). Each layer is synthesized
per-frame on the GPU as a $256\times 256$ half-float texture using an FFT and
displace the vertices both horizontally and vertically with respect to their
tangent frame. Once we have updated the triangulation, we export it into a
visibility buffer (Burns and Hunt, 2013) that we render using the GPU’s
hardware rasterizer. For shading, we rely on physically-based BRDFs
illuminated by a precomputed atmosphere (Bruneton and Neyret, 2008). Thanks to
the adaptivety of our triangulation, we are able to render this particular
shot using only 64k triangles. We refer the reader to our supplemental video
for the animated result.

#### Terrain Components

In Figure 7, we show an elevation-based terrain example over a Moon-sized
surface (i.e., roughly 38 million square kilometers) using NASA’s moon data,
which is available at the following URL: https://svs.gsfc.nasa.gov/cgi-
bin/details.cgi?aid=4720. Our elevation data consists of a $5760\times 2880$
16-bit displacement map coupled with several octaves of simplex noise. The
base mesh and refinement target is the same as the one we described for the
ocean system in the previous paragraph. We also rely on a visibility buffer
for rendering. For shading, we use a diffuse BRDF with an albedo that varies
according to a $4096\times 2048$ texture map.

#### Arbitrary Asset

For the sake of completeness, we also evaluated our method against hardware-
accelerated tessellation shaders over a complex mesh. In Figure 8, we compare
our adaptive triangulation against that of tessellation shaders for a specific
view configuration.

|  |  |
---|---|---|---
|  |  |
Figure 7.  (top) Frames taken from a zoom-in animation over the Moon terrain. (bottom) Aeral wireframe views.  |
---|---
|
Figure 8.  Comparison between (left) tessellation shaders and (right) our
triangulation on a complex mesh.

###  4.2. Performance Measurements

test scene |  Figure 1 |  Figure 7 |  Figure 8
---|---|---|---
($H$ / $D$) | (60 / 17) | (60 / 17) | (21,399 / 18)
update | 0.1 | 0.084 | 0.085
render | 1.745 | 1.863 | 0.1
Table 3.  Performances for various geometries on an AMD 6800 XT GPU. Timings
are given in milliseconds.

#### Absolute Timings

We benchmarked our test scenes on an AMD 6800 XT, which we chose to mimic a
console-level GPU. Since our method runs entirely on the GPU, the CPU does not
play a major role in performances. Nevertheless, we mention we use an Intel
Core i7-13700K for the sake of completeness. We report our performance
measurements for each test scene in Table 3. The update row measures the time
taken to compute an incremental update of our triangulation, which comprises
all 9 kernels from Figure 6. As demonstrated by the reported numbers, our
incremental update is very fast to evaluate, taking less than 0.1ms per frame.
Note that update performances are similar between Figure 7 and Figure 8
despite the CBT being twice as big for the latter scene. This is due to the
way we implement our GenerateCommands kernel, which requires evaluating the
world-space position of each bisector’s vertices; this evaluation is more
expensive for Figure 1 and Figure 7 because we rely on double precision
(otherwise discretization artifacts appear as shown in Figure 9). Note that it
may be possible to avoid the use of double precision via quantization methods
but we have not tried this. As for the rendering row, we sum the timings
required to create the visibility buffer and shade the pixels in the case of
Figure 1 and Figure 7. For Figure 8 we simply rely on forward rendering.

#### Memory Consumption

Here we provide the memory consumption of our implementation for Figure 1 and
Figure 7. We rely on a CBT of depth $D=17$ and 32-bit integers everywhere
except for the bisector index, which is 64-bit wide. This makes a total of 7
MiB of memory (which can be deduced from Table 2) to handle planetary-scale
triangulations.

#### Performances Against the Original CBT Implementation

As mentioned in Section 3, the original CBT implementation (Dupuy, 2020)
couples the maximum depth of the bisectors to that of the CBT, which is set to
depth $D=27$. This has the following implications/limitations:

  1. (1)

The root bisectors can be subdivided at most 27 times. While this is enough
for moderately-sized terrains, it is way too limited for scenes like those of
Figure 1 and Figure 7.

  2. (2)

The implementation requires to allocate memory for $2^{27}$ elements despite
the fact that most of this memory is not used: in practice the adaptive
triangulation produces at most 128k triangles for every viewing conditions we
have tried, i.e., over 99% of the memory is wasted.

  3. (3)

A sum reduction must be computed over $2^{27}$ elements and is the main
bottleneck of the method. On our test hardware, such a computation runs in
0.4ms, which alone is four times slower than our entire update time as
reported in Table 3.

In contrast to the original approach, ours decouples the depth of the CBT to
that of the subdivision. As a consequence, we reach subdivision depths of up
to 64 (as we use 64-bit integers to encode bisector indexes; deeper levels can
be achieved with larger integers) with a memory pool of 128k elements and
therefore a CBT of depth $D=17$. Due to the reduced size of the CBT, we also
avoid a large sum-reduction compared to the original method. Our novel
approach thus produces deeper subdivision levels with less memory while
running faster.

[fp64] | [fp32]
---|---
Figure 9.  Impact of double floating point precision on planetary-scale
tessellation.

##  5\. Conclusion

We introduced an adaptive triangulation method for arbitrary halfedge meshes
that runs entirely on the GPU. Our method is primarily geared towards large-
scale game components such as terrains, water systems and planets, for which
it delivers high performances on console-level GPUs.

## References

  * (1)
  * Asirvatham and Hoppe (2005) Arul Asirvatham and Hugues Hoppe. 2005.  Terrain rendering using GPU-based geometry clipmaps.  _GPU Gems_ 2 (2005), 27–46.
  * Atalay and Mount (2007) F Betul Atalay and David M Mount. 2007.  Pointerless implementation of hierarchical simplicial meshes and efficient neighbor finding in arbitrary dimensions.  _International Journal of Computational Geometry & Applications_ 17, 06 (2007), 595–631.
  * Botsch et al. (2010) Mario Botsch, Leif Kobbelt, Mark Pauly, Pierre Alliez, and Bruno Lévy. 2010.  _Polygon Mesh Processing_.  AK Peters / CRC Press. 250 pages.  https://hal.inria.fr/inria-00538098
  * Bruneton and Neyret (2008) Eric Bruneton and Fabrice Neyret. 2008.  Precomputed Atmospheric Scattering. In _Proceedings of the Nineteenth Eurographics Conference on Rendering_ (Sarajevo, Bosnia and Herzegovina) _(EGSR ’08)_. Eurographics Association, Goslar, DEU, 1079–1086.  https://doi.org/10.1111/j.1467-8659.2008.01245.x
  * Burns and Hunt (2013) Christopher A. Burns and Warren A. Hunt. 2013.  The Visibility Buffer: A Cache-Friendly Approach to Deferred Shading.  _Journal of Computer Graphics Techniques (JCGT)_ 2, 2 (12 August 2013), 55–69.  http://jcgt.org/published/0002/02/04/
  * Campagna et al. (1998) Swen Campagna, Leif Kobbelt, and Hans-Peter Seidel. 1998\.  Directed Edges–A Scalable Representation for Triangle Meshes.  _Journal of Graphics Tools_ 3, 4 (1998), 1–11.  https://doi.org/10.1080/10867651.1998.10487494
  * Deliot et al. (2021) Thomas Deliot, Xiaoling Yao, Jonathan Dupuy, and Kees Rijnen. 2021\.  Experimenting With Concurrent Binary Trees for Large-scale Terrain Rendering. In _ACM SIGGRAPH 2021 Courses_.  https://advances.realtimerendering.com/s2021/index.html
  * Duchaineau et al. (1997) Mark Duchaineau, Murray Wolinsky, David E Sigeti, Mark C Miller, Charles Aldrich, and Mark B Mineev-Weinstein. 1997.  ROAMing terrain: real-time optimally adapting meshes. In _Proceedings. Visualization’97 (Cat. No. 97CB36155)_. IEEE, 81–88.
  * Dupuy (2020) Jonathan Dupuy. 2020\.  Concurrent Binary Trees (with Application to Longest Edge Bisection).  _Proc. ACM Comput. Graph. Interact. Tech._ (2020).  https://doi.org/10.1145/3406186
  * Dupuy and Vanhoey (2021) J. Dupuy and K. Vanhoey. 2021.  A Halfedge Refinement Rule for Parallel Catmull-Clark Subdivision.  _Computer Graphics Forum_ (2021).  https://doi.org/10.1111/cgf.14381
  * Epic (2023) Epic. 2023.  _Water Meshing System and Surface Rendering in Unreal Engine 5_.  https://docs.unrealengine.com/5.0/en-US/water-meshing-system-and-surface-rendering-in-unreal-engine/
  * Etienne (2023) Stephan Etienne. 2023\.  ELarge-Scale Terrain Rendering in Call of Duty. In _ACM SIGGRAPH 2021 Courses_.  https://advances.realtimerendering.com/s2023/index.html#CODTerrain
  * Evans et al. (2001) William Evans, David Kirkpatrick, and Gregg Townsend. 2001\.  Right-triangulated irregular networks.  _Algorithmica_ 30, 2 (2001), 264–286.
  * Hinsinger et al. (2002) Damien Hinsinger, Fabrice Neyret, and Marie-Paule Cani. 2002\.  Interactive Animation of Ocean Waves. In _Proceedings of the 2002 ACM SIGGRAPH/Eurographics Symposium on Computer Animation_ (San Antonio, Texas) _(SCA ’02)_. Association for Computing Machinery, New York, NY, USA, 161–166.  https://doi.org/10.1145/545261.545288
  * Hwa et al. (2004) Lok M Hwa, Mark A Duchaineau, and Kenneth I Joy. 2004\.  Adaptive 4-8 texture hierarchies. In _IEEE Visualization 2004_. IEEE, 219–226.
  * Karis et al. (2021) Brian Karis, Rune Stubbe, and Graham Wihlidal. 2021.  A deep dive into Nanite virtualized geometry. In _ACM SIGGRAPH 2021 Courses_.  https://advances.realtimerendering.com/s2021/index.html
  * Kettner (1999) Lutz Kettner. 1999\.  Using generic programming for designing a data structure for polyhedral surfaces.  _Computational Geometry_ 13, 1 (1999), 65 – 90.  https://doi.org/10.1016/S0925-7721(99)00007-3
  * Lindstrom et al. (1996) Peter Lindstrom, David Koller, William Ribarsky, Larry F Hodges, Nick L Faust, and Gregory Turner. 1996.  _Real-time, continuous level of detail rendering of height fields_.  Technical Report. Georgia Institute of Technology.
  * Lindstrom and Pascucci (2002) Peter Lindstrom and Valerio Pascucci. 2002.  Terrain simplification simplified: A general framework for view-dependent out-of-core visualization.  _IEEE Transactions on Visualization and Computer graphics_ 8, 3 (2002), 239–254.
  * Losasso and Hoppe (2004) Frank Losasso and Hugues Hoppe. 2004.  Geometry Clipmaps: Terrain Rendering Using Nested Regular Grids.  _ACM Trans. Graph._ 23, 3 (aug 2004), 769–776.  https://doi.org/10.1145/1015706.1015799
  * Maubach (1995) Joseph M Maubach. 1995\.  Local bisection refinement for n-simplicial grids generated by reflection.  _SIAM Journal on Scientific Computing_ 16, 1 (1995), 210–227.
  * Mitchell (2016) William F Mitchell. 2016\.  30 years of newest vertex bisection. In _AIP Conference Proceedings_ , Vol. 1738. AIP Publishing.
  * Özturan (1996) Can Özturan. 1996\.  _Worst Case Complexity of Parallel Triangular Mesh Refinement by Longest Edge Bisection._ Technical Report. Institute for Computer Applications in Science and Engineering.
  * Rivara (1984) M Cecilia Rivara. 1984\.  Algorithms for refining triangular grids suitable for adaptive and multigrid techniques.  _International journal for numerical methods in Engineering_ 20, 4 (1984), 745–756.
  * Tessendorf et al. (2001) Jerry Tessendorf et al. 2001\.  Simulating ocean water.  _SIGGRAPH Course notes_ (2001), 5.
  * Velho (2000) Luiz Velho. 2000\.  Semi-regular 4-8 refinement and box spline surfaces. In _Proceedings 13th Brazilian Symposium on Computer Graphics and Image Processing (Cat. No. PR00878)_. IEEE, 131–138.
  * Velho and Zorin (2001) Luiz Velho and Denis Zorin. 2001.  4–8 Subdivision.  _Computer Aided Geometric Design_ 18, 5 (2001), 397–427.
  * Weiler (1985) K. Weiler. 1985\.  Edge-Based Data Structures for Solid Modeling in Curved-Surface Environments.  _IEEE Computer Graphics and Applications_ 5, 1 (1985), 21–40.  https://doi.org/10.1109/MCG.1985.276271
  * Weiss (2011) Kenneth Weiss. 2011\.  _Diamond-based models for scientific visualization_.  Ph. D. Dissertation.
  * Weiss and De Floriani (2011) Kenneth Weiss and Leila De Floriani. 2011.  Simplex and diamond hierarchies: Models and applications. In _Computer Graphics Forum_ , Vol. 30. Wiley Online Library, 2127–2155.
  * Yalçın et al. (2011) M Adil Yalçın, Kenneth Weiss, and Leila De Floriani. 2011\.  GPU algorithms for diamond-based multiresolution terrain processing. In _Eurographics Symposium on Parallel Graphics and Visualization_. 10–11.