# Virtually Geometric

**URL:** <https://discourse.threejs.org/t/virtually-geometric/28420>\
**Category:** Showcase\
**Tags:** lod, geometry\
**Created:** [July 28, 2021, 6:26am UTC](https://discourse.threejs.org/t/virtually-geometric/28420 "2021-07-28T06:26:20Z")\
**Posts on this page:** 17\
**Page:** 4

<div class="post-metadata">

**Author:** ![Usnul](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/usnul/32/2355_2.png) [@Usnul](https://discourse.threejs.org/u/Usnul)\
**Post date:** [September 18, 2024, 5:14pm UTC](https://discourse.threejs.org/t/virtually-geometric/28420/61 "2024-09-18T17:14:23Z")

</div>

> [@mjurczyk](#):
>
> but it’s not really useful for network-based platforms.

au contraire

It’s an interesting thing to think about. The Nanite presentations talk about the asset size angle a lot actually.

Say you have a 2GB asset, and you “Nantize” it, it’s probably around 2GB now, maybe a bit more because you have some redundancy and more information in general. How do you fit all that in the GPU memory? - well, you don’t. You fit the metadata onto the GPU, and you split the data into fixed-sized packet, so you can upload them onto the GPU on-demand. In fact, that’s how it can run so fast.

Where does that bring us on the web? Imagine loading a 2GB mesh in milliseconds? Well, you can do that by just downloading the metadata and just the packets that contain clusters of your target resolution.

Better yet, you can download those clusters in a progressive order, starting from most coarse LOD level, and the mesh will appear more defined over-time.

From my experience doing some unscientific residency testing, I found that unless you’re doing a demo zooming in on every part of an asset and spinning it around - you’re typically below 20% utilization, that is - you’re only ever interacting with up to 20% of all of the clusters. And it scales really well, that is - the larger the asset - the lower the utilizaiton.

Just like with the [virtual textures](https://discourse.threejs.org/t/virtual-textures/53353), I think this tech is suited for the web very well.

The problem is in complexity that comes with nanite itself, and then data structure design and the whole memory management system. I’m quite comfortable in that area, but even I didn’t go for it yet, as it’s just a massive amount of work.

I’ve seen a lot of people use [Draco](https://google.github.io/draco/) on the web to save on traffic, even when the mesh are not that big and were explicitly designed for the application, the argument goes that it saves precious time-to-first-contentful or whatever you may call it.

Personally - I hate [Draco](https://google.github.io/draco/), with a passion. I think it’s one of the worst things to happen to 3d on the web. It’s implementation is trash, as it spins [up 4 worker threads](https://github.com/mrdoob/three.js/blob/17abdb5e4b88368a6c1528743d014e641b32cf85/examples/jsm/loaders/DRACOLoader.js#L24) by default and hogs that resource forever. It’s incredibly slow to decode assets, making it more of a coin-toss whether on a good connection you’d just download the unpacked asset faster or not. You just added a ton of complexity to your pipeline for dubious gain.

Virtual geometry on the other hand is naturally streamable, and allows you to offer meaningful content to the user at as low as 1 cluster’s worth of data transfer, something like say 128 triangles, with 19 bytes per vertex, or around 2.47 kb per cluster. That’s it, no matter how large your actual dataset is - you can draw a very-very coarse 128 traignle representation of it for the user with just 2.47 kb of data needed to be transferred.

You can then apply whatever your favourite type of compression to it or just configure the webserver to gzip it.

---

<div class="post-metadata">

**Author:** ![kpachinger](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/kpachinger/32/4616_2.png) [@kpachinger](https://discourse.threejs.org/u/kpachinger)\
**Post date:** [September 18, 2024, 10:05pm UTC](https://discourse.threejs.org/t/virtually-geometric/28420/62 "2024-09-18T22:05:43Z")

</div>

Interesting, how you use custom meta data to define geometry. The physical model’s extensability is the nature of the request. It’s like logarithmic scale from a universe (geography) to an atom (biology). And your fluid LOD uses superpixel patches. With discretion, select deterministic simulations could run outside of screen space… for instance a tracer bullet trajectory. ROAM could further implement dynamic systems to account for complexity, tortuosity, continuum. This is the antithesis of a superresolution upsample.

The core asset library is vital to utilize memory. This may elicit even deeper relationships in an abstract layer. For example, Metahumans use poses and Intelligent Scissors use targets. A modern node system may use generative breakpoints to affect a hot loop.

Or some such multivariate ethical consensus to progress.

Cheers,  
LAN Sk8ps

---

<div class="post-metadata">

**Author:** ![Attila\_Schroeder](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/attila_schroeder/32/36097_2.png) [@Attila\_Schroeder](https://discourse.threejs.org/u/Attila_Schroeder)\
**Post date:** [September 18, 2024, 10:18pm UTC](https://discourse.threejs.org/t/virtually-geometric/28420/63 "2024-09-18T22:18:19Z")

</div>

> [@mjurczyk](#):
>
> … If you dedicate time and start reading through the docs / sample codes from other implementations / papers - you will inevitably reach a similar result and can open source it 🙇‍♂️

I did 😊

 ![dragon_wireframe](https://canada1.discourse-cdn.com/flex035/uploads/threejs/original/3X/6/d/6d0dbdfb1084c344bd9b90dd99e2b1e63823a157.jpeg)

 ![dragons_wireframe](https://canada1.discourse-cdn.com/flex035/uploads/threejs/original/3X/6/4/64282942f93300756c76fe67aa5075eda8f2617e.jpeg)

It is not yet as efficient as I would like it to be, but I will solve that. Since I only work with three.webgpu.js, WebGPU offers exactly the right techniques, but these still need to be implemented in threejs. This could already be done much more efficiently, but not in the modern way that webgpu could. I already have an issue in the developer forum about one of these points. In webgpu you can let the GPU decide for itself whether something should be rendered or not. drawIndirect + compute shader. But DrawIndirect and the associated peripherals are a major construction site.

---

<div class="post-metadata">

**Author:** ![Umbawa\_Sarosong](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/umbawa_sarosong/32/30107_2.png) [@Umbawa\_Sarosong](https://discourse.threejs.org/u/Umbawa_Sarosong)\
**Post date:** [January 12, 2025, 7:17pm UTC](https://discourse.threejs.org/t/virtually-geometric/28420/64 "2025-01-12T19:17:25Z")

</div>

I loved the WebGPU nanite works, a million model existing all at once in a single scene is amazing, can you make a version where we can load gltf models, that would be awesome.

 ![image](https://canada1.discourse-cdn.com/flex035/uploads/threejs/original/3X/e/e/ee543d3f9ec580d52240c6b05ab3dc4abd3bb383.jpeg)

Here are the same [lod simplifier project](https://theneoverse.web.app/#threeviewer&&load=12) I used before but its obsolete, I couldn’t be bothered diving into the code (I am hooked up on my day job), it can load gltf and simplify the gltf model, but it is lacking the capabilities of virtual textures where when the camera is far the texture should also be reduce down to lower resolution.

Zoom out and use the magnify glass to see the level of details turned to low poly

 ![image](https://canada1.discourse-cdn.com/flex035/uploads/threejs/original/3X/1/d/1d509bfd3c23545b259cba2ce1f9a36b0fbd0654.jpeg)

Observe the mesh changes from high poly to low poly as you zoom out.

 ![image](https://canada1.discourse-cdn.com/flex035/uploads/threejs/original/3X/0/6/06200f4d7a6ce770bd2db8cec2f1e3617ab2a27a.jpeg)

The tires curvature is smooth

 ![image](https://canada1.discourse-cdn.com/flex035/uploads/threejs/original/3X/f/9/f98da0fd1680a2bf256f1b47c15176ff08b8925a.png)

The tire curvature becomes low poly as you zoomed out

[Demo](https://theneoverse.web.app/#threeviewer&&load=12)

[Source](https://theneoverse.web.app#pSN20251022005)

To zoom out hit key “O” for orbit, then mouse wheel to zoom out, then observe how the mesh reduce polygons as it goes further and further from the objects.

The [simplifier](https://threejs.org/examples/?q=simpli#webgl_modifier_simplifier) works just as well as the threejs nanite using threejs simplify mesh and uv mapping.

The difference with this approach and nanite is the nanite demo works on few model to exist in quantity (which doesn’t happen in practical use unless you want to exhibit an army of a few models) while the simplifier works on different models which works on practical application such as the demo above.

The Crateria City is a demonstration of virtual geometry where farther away mesh crunched to its simplest to ease browser memory.

Resources:

[Crateria City](https://www.turbosquid.com/FullPreview/2426820)

[Serini & Suron City](https://www.renderhub.com/thebeachmarket/serini-suron-island-cities)

[Live Demo](https://theneoverse.web.app/#serini&&serini)

LOD using mesh simplifier implementation makes three.js + cannon.js smooth character & vehicle movement possible.

Other samples:

1. [Sandyards Market](https://theneoverse.web.app/#threeviewer&&sandyards-market)
2. [Suite](https://theneoverse.web.app/#threeviewer&&suite)
3. [Speed Way](https://theneoverse.web.app/#threeviewer&&speed-way)
4. [Vista District](https://theneoverse.web.app/#threeviewer&&vistadistrict)
5. [Underground bunker](https://theneoverse.web.app/#threeviewer&&underground-bunker)

---

<div class="post-metadata">

**Author:** ![ventoline](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/ventoline/32/29642_2.png) [@ventoline](https://discourse.threejs.org/u/ventoline)\
**Post date:** [October 10, 2025, 9:09pm UTC](https://discourse.threejs.org/t/virtually-geometric/28420/65 "2025-10-10T21:09:38Z")

</div>

did you make it open source in the end? 🙏 😅

---

<div class="post-metadata">

**Author:** ![JulyTheMonth](https://avatars.discourse-cdn.com/v4/letter/j/6bbea6/32.png) [@JulyTheMonth](https://discourse.threejs.org/u/JulyTheMonth)\
**Post date:** [October 16, 2025, 7:14am UTC](https://discourse.threejs.org/t/virtually-geometric/28420/66 "2025-10-16T07:14:33Z")

</div>

I am a bit late to the party.

One open-source implementation of a similiar tech I have found is here: [GitHub - cnr-isti-vclab/nexus: Nexus is a c++/javascript library for creation and visualization of a batched multiresolution mesh](https://github.com/cnr-isti-vclab/nexus)

Here they use the name multiresolutional meshes, but the tech has the same idea. This disseration also sums up the idea of this tech: [https://vcg.isti.cnr.it/~ponchio/download/ponchio\_phd.pdf](https://vcg.isti.cnr.it/~ponchio/download/ponchio_phd.pdf)

They developed it with the background displaying very high resolution scans of objects, but I think it could also be used for other stuff.

---

<div class="post-metadata">

**Author:** ![trusktr](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/trusktr/32/13726_2.png) [@trusktr](https://discourse.threejs.org/u/trusktr)\
**Post date:** [December 29, 2025, 8:02am UTC](https://discourse.threejs.org/t/virtually-geometric/28420/67 "2025-12-29T08:02:04Z")

</div>

> [@Usnul](#):
>
> Better yet, you can download those clusters in a progressive order, starting from most coarse LOD level, and the mesh will appear more defined over-time.

Sounds like Google Maps or Apple Maps in 3D mode!

---

<div class="post-metadata">

**Author:** ![Umbawa\_Sarosong](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/umbawa_sarosong/32/30107_2.png) [@Umbawa\_Sarosong](https://discourse.threejs.org/u/Umbawa_Sarosong)\
**Post date:** [January 4, 2026, 12:12am UTC](https://discourse.threejs.org/t/virtually-geometric/28420/68 "2026-01-04T00:12:06Z")

</div>

Yes, there is. I made an open browser-based version available and shared it as a reference for virtual geometry and LOD experiments. You can check it here:  
[https://theneoverse.web.app/#threeviewer&&construct](https://theneoverse.web.app/#threeviewer&&construct)

[![](https://img.youtube.com/vi/0TZ3F1haDA0/maxresdefault.jpg "Loading Game map from SketchFab") ](https://www.youtube.com/watch?v=0TZ3F1haDA0)

 ![Screenshot 2026-01-04 035736](https://canada1.discourse-cdn.com/flex035/uploads/threejs/original/3X/7/e/7e8033b677c3d25a1d0d20514c4b23b9f4ecfc2a.jpeg)

to show the drag & drop modal click “construct” button:  
 ![image](https://canada1.discourse-cdn.com/flex035/uploads/threejs/original/3X/f/6/f6282dfcb82d69d1c000575bc87ac20a8bc97d85.png)

you can load GLB files directly in the browser, including levels, characters, and vehicle models, which makes quick prototyping and experimentation much easier.

here are sample GLB’s i downloaded from SketchFab: [https://drive.google.com/file/d/1g4LZUEn3W2vQUtg5x9YcxiE52nYmiR2b/view?usp=sharing](https://drive.google.com/file/d/1g4LZUEn3W2vQUtg5x9YcxiE52nYmiR2b/view?usp=sharing)

here is the book discussing #threeverse virtual experience engine:

[Virtual Experience Engine.pdf](https://discourse.threejs.org/uploads/short-url/7UXsDc299zjKSSto56azsdttI7f.pdf) (5.0 MB)

I prepared this documentation for anyone to continue this project.

Enjoy!

---

<div class="post-metadata">

**Author:** ![Umbawa\_Sarosong](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/umbawa_sarosong/32/30107_2.png) [@Umbawa\_Sarosong](https://discourse.threejs.org/u/Umbawa_Sarosong)\
**Post date:** [January 4, 2026, 1:17am UTC](https://discourse.threejs.org/t/virtually-geometric/28420/69 "2026-01-04T01:17:59Z")

</div>

To build the source code first you will need to download the threejs-main from github, then you will need to place the build in a folder `assets/js` then place the `sample/jsm` in `assets/js` then on your main folder you will need this files:

[crt-screen.css](https://discourse.threejs.org/uploads/short-url/xho9odM0uSZrfFDsUgujkVFjo2I.css) (7.9 KB) - this are the effects that makes it looks crt like

[style.css](https://discourse.threejs.org/uploads/short-url/18bLQ2TZef1jXJGDNzwCLxBWzje.css) (1.5 KB) - this is just standard style

[construct.html](https://discourse.threejs.org/uploads/short-url/wwV1hwIbpyAHNyMMa10flncfanQ.html) (71.3 KB) - this is the html that you need to open

[index.html](https://discourse.threejs.org/uploads/short-url/nFepCqRO8RhOGSQ2gouAz4F5uXu.html) (771.5 KB) - this is the html main (the contruct.html calls this)

and the most important part is this two in `assets/js`:

[index.js](https://discourse.threejs.org/uploads/short-url/9N1soTk0k6XV2qKM5neAATvIo8g.js) (2.4 KB) - this is what initiate three.js (just standard three.js initiate), _this is a 4 year old code so you must update it_. I never updated it.

[interactive.js](https://discourse.threejs.org/uploads/short-url/kjTZ1Q4SW5oIxepFCj6LIu8UtDa.js) (138.2 KB) - this is the file that controls everything. _(sometimes when there is a issue on three.js update you also have to update)._ This is where I put all codes and its accessing three.js libraries.

or just use the GitHub: [https://github.com/VeinSyct/ThreeJsCannon](https://github.com/VeinSyct/ThreeJsCannon)

i prefer to work locally all the libraries downloaded because it’s fast and also stable avoiding the issue of cache and all online issue that makes me guessing is the internet on or off. working offline is consistent.

Good luck!

---

<div class="post-metadata">

**Author:** ![Usnul](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/usnul/32/2355_2.png) [@Usnul](https://discourse.threejs.org/u/Usnul)\
**Post date:** [September 10, 2026, 4:41pm UTC](https://discourse.threejs.org/t/virtually-geometric/28420/70 "2026-09-10T16:41:49Z")

</div>

Been finding time to work on a Virtual Geometry system for WebGPU

[![](https://i.ytimg.com/vi/Sf-kbU1ov0c/hqdefault.jpg "Virtual Geometry (WebGPU)") ](https://www.youtube.com/watch?v=Sf-kbU1ov0c)

There are loosely 3 parts:

- format
- converter
- renderer

# Format

> done

Format is the major part, because we’re on the internet, and we can’t assume SSD loading speeds.

In a way, I’ve been designing the file format for the past 5 years, mostly slowly and in the back of my mind. The initial idea came from [Brian Karis](https://x.com/BrianKaris)’s presentation on nanite from 2021. Epic games recognized that a virtual geometry system becomes less useful if the entire asset needs to fit in memory, so they build a paging structure around clusters, a DAG over cluster DAG. But they still kept the metadata fully resident.

This format is a logical extension of that, but making the structure completely discoverable, requiring nothing beyond a fixed-size asset header to be resident. It’s a bit extreme, but it means if we had trillions of triangles - the format would still hold up.

Because we’re on the internet, the format needs to be streamable, and to make it such - we have to account for peculiarities of http RANGE requests.

The actual graph representation itself, the contents of the file is not super interesting, but [I did post about it if anyone cares](https://x.com/SoftEngineer/status/2091106117803733498?s=20).

Worth noting that clusters are encoded and compressed with lossless compression codec. Compression is similar to something like meshopt.

* * *

# Converter

> done

This is the interesting bit. Splitting the mesh up and merging it up again is easy in principle, and I read probably more takes on this than is healthy to. Everyone has an idea, and everyone has a preference.

My take is rather simple:

1. we must be close to optimal
2. we must encode perfect error information for reconstruction

It’s simple, but it’s not easy. The first part means we have to have state-of-the-art mesh simplification implementation, and it took me close to 3 months of effort to build that in spare time between 2022 and 2024.

We also can’t use naive clustering (partitioning), which, luckily for me, I already solved previously.

The converter is slow, it’s about 50k triangles per second, which means if you have a 5,000,000 triangle asset, it would take you 1 minute and 40 seconds just to convert it. For reference, Nanite was advertised to have speed of 1M triangles per second. But it’s not clear whether that’s single core, and it’s likely using SIMD, which is not available to me. The good news is that conversion is done once.

* * *

# Renderer

This is the part that’s not not done yet. The video shows a quick and dirty renderer, used for testing.

I say “Renderer”, but really it’s a runtime, we have a number of problems to solve here:

1. provide geometry cut per view with clusters to render. “Per view” means we have to work with shadows too.
2. manage data streaming. Record and read requests from the GPU, manage CPU-side cache, prioritize network requests, deal with hysteresis.
3. manage N virtual geometries at the same time. The cost must be O(1) or at least sub-linear to N
4. be very memory efficient. Even just storing cluster headers as plain JS objects in RAM quickly becomes untennable.

---

<div class="post-metadata">

**Author:** ![Ranao](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/ranao/32/26878_2.png) [@Ranao](https://discourse.threejs.org/u/Ranao)\
**Post date:** [September 11, 2026, 2:10pm UTC](https://discourse.threejs.org/t/virtually-geometric/28420/71 "2026-09-11T14:10:12Z")

</div>

has this practically implemented in any real project application? sure its cool to see the demos.

---

<div class="post-metadata">

**Author:** ![Usnul](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/usnul/32/2355_2.png) [@Usnul](https://discourse.threejs.org/u/Usnul)\
**Post date:** [September 11, 2026, 2:19pm UTC](https://discourse.threejs.org/t/virtually-geometric/28420/72 "2026-09-11T14:19:09Z")

</div>

I can’t say the name, but yes, this tech I worked on previous is in production and has been for ~5 years now. Can’t say for others.

As for the WebGPU implementation - my main motivation is for terrain, actually. Terrain is a large piece of geometry usually, and having a custom LOD solution for it is always a pain.

Beyond that, I think virtual geometry fits the web context much better than native, because of the network limitation. Being able to load massive assets instantly and have the detail stream in as needed is just such a great fit.

---

<div class="post-metadata">

**Author:** ![Usnul](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/usnul/32/2355_2.png) [@Usnul](https://discourse.threejs.org/u/Usnul)\
**Post date:** [September 15, 2026, 2:41pm UTC](https://discourse.threejs.org/t/virtually-geometric/28420/73 "2026-09-15T14:41:02Z")

</div>

Worked a some more on this problem. I’ve had the NVIDIA’s Zorah asset that they worked on with Epic Games guys for their demo back a year or two ago

I thought it’s a good stress test for virtual geometry

[![](https://i.ytimg.com/vi/q-IPKGKMylo/hqdefault.jpg "1.6 billion triangles in the browser") ](https://www.youtube.com/watch?v=q-IPKGKMylo)

It’s ~1,6B triangles in source geometry, and with instacing here it’s 10.7B triangles

There are still a few issues with streaming and memory compaction, but after weeks of just working on the format and conversion and scoping out the runtime it runs and loads the entire scene

The load time is also near instant, I intentionally reload the page ~0:26 timestamp

The converted assets are 50.1GB, the streaming is entirely demand-driven, so in a normal case it would be a small trickle, not like here, where I’m flying through the scene and getting really close up to everything on a 4k display

Even so, by the end of the demo in the video we’re ~2.1GB data loaded, which is a lot. The CPU-side RAM cache only holds 1GB though, and VRAM usage is staying below 512MB

The format is made to be streamable and GPU friendly. There is a decompression step, with LZ4 used in this demo, but once decompressed it gets shipped to the GPU without any surgery or modifications.

The Zorah asset is actually a pretty bad usecase for virtual geometry, as it has a lot of intricate detail and a lot of foliage. Mesh simplification quickly introduces large error, so the driver is forced to stream fairly high resolution clusters (low LoD levels), so it’s a good torture test.

---

<div class="post-metadata">

**Author:** ![Usnul](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/usnul/32/2355_2.png) [@Usnul](https://discourse.threejs.org/u/Usnul)\
**Post date:** [September 16, 2026, 3:13am UTC](https://discourse.threejs.org/t/virtually-geometric/28420/74 "2026-09-16T03:13:27Z")

</div>

Solved most of the frame hitches and a couple of cut refinement bugs that creates visual artifacts

[![](https://i.ytimg.com/vi/NPvdbcrxjGE/hqdefault.jpg "Virtual Geometry in Browser (10B triangles)") ](https://www.youtube.com/watch?v=NPvdbcrxjGE)

---

<div class="post-metadata">

**Author:** ![Usnul](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/usnul/32/2355_2.png) [@Usnul](https://discourse.threejs.org/u/Usnul)\
**Post date:** [September 17, 2026, 7:10pm UTC](https://discourse.threejs.org/t/virtually-geometric/28420/75 "2026-09-17T19:10:29Z")

</div>

Chased down stubborn conversion edge cases, so the entire Zorah asset is now loaded in

[![](https://i.ytimg.com/vi/IS2NxJxQDL0/hqdefault.jpg "18,885,367,310 triangles in the Browser") ](https://www.youtube.com/watch?v=IS2NxJxQDL0)

That’s 18,885,367,310 source triangles.

[![](https://img.youtube.com/vi/xHQMehFJ0AY/maxresdefault.jpg "Zorah | A New Era of Rendering, Powered by GeForce RTX 50 Series and AI") ](https://www.youtube.com/watch?v=xHQMehFJ0AY)

I remember seeing NVIDIA’s demo of the asset one year ago and thinking to myself

> I’m gonna get this running in the browser one day

I had the goal of loading the entire asset and having it be interactive in WebGPU, and I consider that goal to have been achieved now.

---

<div class="post-metadata">

**Author:** ![Ranao](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/ranao/32/26878_2.png) [@Ranao](https://discourse.threejs.org/u/Ranao)\
**Post date:** [September 18, 2026, 4:53am UTC](https://discourse.threejs.org/t/virtually-geometric/28420/76 "2026-09-18T04:53:17Z")

</div>

the only issue with this is the texture, it does run smooth without texture, how do you rebuild the texture back?

---

<div class="post-metadata">

**Author:** ![Usnul](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.threejs.org/usnul/32/2355_2.png) [@Usnul](https://discourse.threejs.org/u/Usnul)\
**Post date:** [September 18, 2026, 4:27pm UTC](https://discourse.threejs.org/t/virtually-geometric/28420/77 "2026-09-18T16:27:23Z")

</div>

Interesting question.

Soooo… a bit of a history. NVIDIA did the Zorah sample together with Epic team, it was done as an UnrealEngine project.

To make the data accessible for researchers - they exported it as GLTF, but everything in GLTF is stripped, no normals, no UVs, just positions. Meaning no materials either.

To recover material you have to take the original 100+ GB unreal project and extract from that. Which I’m actually doing, but it’s a whole new set of problems to solve

Some partial success already

 ![image](https://canada1.discourse-cdn.com/flex035/uploads/threejs/original/3X/4/f/4f20a95bdcbe47eca8ee7326be6ffa48c87d5ebf.jpeg)  
 ![image](https://canada1.discourse-cdn.com/flex035/uploads/threejs/original/3X/7/7/770d6057b2edf5c7468146316827b70712368369.jpeg)

[Previous page](https://discourse.threejs.org/t/virtually-geometric/28420.md?page=3)