Is it possible to view LOD changes in editor view or is it supposed to work in render only? I set up a scene with LODSpatial and a camera, but when I move the camera, LODs do not change in the camera preview viewport.

Hello.

• reproduced all from installation steps, but it didn't hide any objects.
• downloaded demo project, launched it, see no spheres were disappeared after looked from far distance

But when I launched game debug (triangle button) - than it showed me hiding. Not sure where problem is.

Maybe some version mismatch (used latest master of this plugin, Godot v3.2.3 stable). Does anybody has any hints on fixing this ?

Thanks.

I have a tree I modeled in Blender and exported to Godot, as well as a billboard impostor (image on a quad), but the LODs don't switch in game.

Both LODs are visible in editor as expected

Both LODs are also still visible in game, unexpected behaviour

How it's supposed to look in game:

Exact Godot version: v3.5.rc6.mono.official [f05cecdc4]

I'll leave it here just in case. don't want to poke you over this since Godot 4 has it covered, but still. What's changed:

1. Structured scene.
2. Meshes are attached as children to Scene_items nodes, so no need to name them in any specific way.
3. LOD distances are relative, values are multiplied by the size of the parent node LODs
4. removed get_children() loop.

Scene with embedded script:

[gd_scene load_steps=2 format=2]

[sub_resource type="GDScript" id=1]
script/source = "# Copyright © 2020 Hugo Locurcio and contributors - MIT License
# See `LICENSE.md` included in the source distribution for details.
extends Spatial

# If `false`, LOD won't update anymore. This can be used for performance comparison
# purposes.
export var enable_lod = true

# The maximum LOD 0 (high quality) distance in units.
export var lod_0_relative_distance = 5

# The maximum LOD 1 (medium quality) distance in units.
export var lod_1_relative_distance = 25

# The maximum LOD 2 (low quality) distance in units.
# Past this distance, all LOD variants are hidden.
export var lod_2_relative_distance = 150

# The rate at which LODs will be updated (in seconds). Lower values are more reactive
# but use more CPU, which is especially noticeable with large amounts of LOD-enabled nodes.
# Set this accordingly depending on your camera movement speed.
# The default value should suit most projects already.
# Note: Slow cameras don't need to have LOD-enabled objects update their status often.
# This can overridden by setting the project setting `lod/refresh_rate`.
export var refresh_rate = 0.25

# The internal refresh timer.
var timer = 0.0


func _ready():

	# Add random jitter to the timer to ensure LODs don't all swap at the same time.
	randomize()
	timer += rand_range(0, refresh_rate)


# Despite LOD not being related to physics, we chose to run in `_physics_process()`
# to minimize the amount of method calls per second (and therefore decrease CPU usage).
func _physics_process(delta):
	if not enable_lod:
		# Show
		show_scenes(\"LOD0\")
		# Hide
		hide_scenes(\"LOD1\")
		hide_scenes(\"LOD2\")
		hide_scenes(\"LOD3\")
		return

	# We need a camera to do the rest.
	var camera = get_viewport().get_camera()
	if camera == null:
		return

	if timer <= refresh_rate:
		timer += delta
		return

	timer = 0.0

	var distance = camera.global_transform.origin.distance_to(global_transform.origin)
	# The LOD level to choose (lower is more detailed).
	# Multiply distance values by scale for relativism.
	if distance < lod_0_relative_distance * self.scale.length():
		# Show
		show_scenes(\"LOD0\")
		# Hide
		hide_scenes(\"LOD1\")
		hide_scenes(\"LOD2\")
		hide_scenes(\"LOD3\")
	elif distance < lod_1_relative_distance * self.scale.length():
		# Show
		show_scenes(\"LOD1\")
		# Hide
		hide_scenes(\"LOD2\")
		hide_scenes(\"LOD0\")
		hide_scenes(\"LOD3\")
	elif distance < lod_2_relative_distance * self.scale.length():
		# Show
		show_scenes(\"LOD2\")
		# Hide
		hide_scenes(\"LOD1\")
		hide_scenes(\"LOD0\")
		hide_scenes(\"LOD3\")
	else:
		# Show
		show_scenes(\"LOD3\")
		# Hide
		hide_scenes(\"LOD0\")
		hide_scenes(\"LOD1\")
		hide_scenes(\"LOD2\")
		

func show_scenes(lod_name):
	self.get_node(lod_name).get_node(\"Scene_items\").show()
			
func hide_scenes(lod_name):
	self.get_node(lod_name).get_node(\"Scene_items\").hide()
"

[node name="LODs" type="Spatial"]
script = SubResource( 1 )
__meta__ = {
"_editor_description_": "Do not rename or edit the nodes.
Put meshes into Scene Items nodes"
}

[node name="LOD0" type="Spatial" parent="."]
__meta__ = {
"_edit_lock_": true
}

[node name="Scene_items" type="Spatial" parent="LOD0"]
__meta__ = {
"_edit_lock_": true
}

[node name="LOD1" type="Spatial" parent="."]
__meta__ = {
"_edit_lock_": true
}

[node name="Scene_items" type="Spatial" parent="LOD1"]
__meta__ = {
"_edit_lock_": true
}

[node name="LOD2" type="Spatial" parent="."]
__meta__ = {
"_edit_lock_": true
}

[node name="Scene_items" type="Spatial" parent="LOD2"]
__meta__ = {
"_edit_lock_": true
}

[node name="LOD3" type="Spatial" parent="."]
__meta__ = {
"_edit_lock_": true
}

[node name="Scene_items" type="Spatial" parent="LOD3"]
__meta__ = {
"_edit_lock_": true
}

Hello, great addon, i propose an improve update, add a debug view with a color system ; the idea is to show all LOD level in the viewport with a color identifier.

Actually, hard to see if the distance set is efficient.

Edit : i can make a quick draw with toshop to give how to see this system.

Remember that suggestion @lawnjelly made about the way LODs are updated? Well this pull request has this feature implemented. the refresh project settings have been replaced with refresh_threshold_ms. The lower this value is, the less time the plugin has to update LODs in the scene, and thus the less that can be updated in one frame. LODs that aren't processed in a certain frame will have to wait till the next one. This proves to be very flexible as no matter how many LODs are in a scene. Only so much can be updated within the allocated time, improving performance and scalability.

The Node inspector UIs were also given a makeover.

Maintainer edit: This closes #3.

I don't know whether this is possible in gdscript with a singleton, but you may be able to make the updates more efficient:

Calling _physics_process for a large number of nodes is quite inefficient even if just a stub function, especially if physics tick rate is e.g. 60 tps. With 1000 nodes, that is 60,000 updates per second, most of which are stubs.

A more efficient paradigm might be instead to register each LOD node when added to the scenetree with a central updater, and unregister when removed from the scene tree.

The central updater could then run on a single _physics_process (or _process) and go through the list of registered nodes and update a certain number each update, calculated to give them all on average an update every 0.25 seconds.

In our example of 1000 nodes that would be: desired updates per second = (1000 * 4) updates per tick at 60tps = 4000 / 60 = 66.6

4000 updates per second is a reduction of 15x. In addition, you could do further approaches like reduce the update rate on far away nodes, and check them every second.

There are also a number of other optimizations which are common with collision detection, but these may well be overkill unless you had a large number of nodes.

When the camera FOV decreases, the distances should be multiplied accordingly so distant objects still look detailed. The user-supplied camera distances will be specified for the default camera FOV (which is 70 in Godot 3.2.x).

There should be a project setting to disable this LOD adjustment in case it's not desired (e.g. for a game where the FOV is only changed for aesthetic reasons).

I've also considered using screen density-based LOD calculations, but they have an additional performance cost and some downsides (such as making high-resolution gaming even slower than it would be otherwise).