thomasup

made a short script, that shows the limits:

it adds a button to the UI: currently it is creating a mesh, with the near and far limits & angle limits.
downside: you have to undo / delete it & click the button again, every time you change a limit value.
upside: you dont have to export to find out

maybe this can be fleshed out & integrated into v3d natively

# Author: Thomas Pahler @ UP Designstudio

import bpy, bmesh, mathutils, math

def draw():
    camera = bpy.context.active_object

    obj = bpy.context.scene.objects.get("debugCube")
    if not obj:
        mesh = bpy.data.meshes.new("debugCube")
        obj = bpy.data.objects.new(mesh.name, mesh)
        scene = bpy.context.scene
        scene.collection.objects.link(obj)
    else:
        mesh = obj.data

    verts = []
    edges = []
    faces = []

    # get camera limits
    tgt = camera.data.v3d.orbit_target
    pos = camera.location
    camDirection = pos-tgt
    near = camDirection.normalized()*camera.data.v3d.orbit_min_distance+tgt
    far  = camDirection.normalized()*camera.data.v3d.orbit_max_distance+tgt

    # add cross at target position
    def drawCross (position):
        verts.append(position-mathutils.Vector((0,1,0)))
        verts.append(position+mathutils.Vector((0,1,0)))
        verts.append(position-mathutils.Vector((1,0,0)))
        verts.append(position+mathutils.Vector((1,0,0)))
        verts.append(position-mathutils.Vector((0,0,0)))
        verts.append(position+mathutils.Vector((0,0,1)))
    drawCross(tgt)

    #add line from near to far, in camera direction
    verts.append(near)
    verts.append(far)

    #add circles
    count = 32

    #add circle for horizontal limits at near limit distance
    angle = camera.data.v3d.orbit_min_azimuth_angle
    endAngle = camera.data.v3d.orbit_max_azimuth_angle
    sweepAngle = endAngle-angle

    for i in range(count):
        angle += sweepAngle/count
        verts.append(mathutils.Vector((math.sin(angle),-math.cos(angle),0)) *camera.data.v3d.orbit_min_distance + tgt)

    #add circle for vertical limits at far limit distance    
    angle = camera.data.v3d.orbit_min_polar_angle
    endAngle = camera.data.v3d.orbit_max_polar_angle
    sweepAngle = endAngle-angle

    for i in range(count):
        angle += sweepAngle/count
        verts.append(mathutils.Vector((0,-math.sin(angle),math.cos(angle))) *camera.data.v3d.orbit_max_distance + tgt)
    
    # make edges
    for i in range(int(len(verts)/2)):
        edges.append([i*2,i*2+1])

    mesh.from_pydata(verts, edges, faces)

    #def emptyAtPosition (name, position, direction):
    #    obj = bpy.context.scene.objects.get(name)
    #    o = bpy.data.objects.new( "empty", None )
    

class DrawCameraLimits(bpy.types.Operator):
    bl_idname = "v3d.draw_camera_limits"
    bl_label = "Draw Limits"
    bl_options = {"REGISTER", "UNDO"}

    def execute(self, context):
        draw()
        return {'FINISHED'}

def menu_func(self, context):
    self.layout.operator(DrawCameraLimits.bl_idname)

bpy.utils.register_class(DrawCameraLimits)
bpy.types.V3D_PT_CameraSettings.append(menu_func)

#bpy.ops.v3d.draw_camera_limits()

indeed, there are many factors to it. basically, the proposal was to add more metrics to the performance profile.

currently, it only says:
Scene Loading Time: 24111ms

my proposal would be smth like:

Total Scene Loading Time: 24.11s
gltf Download: 2s
decompressing: 1.2s
Loading Geometry: 4.10s
Texture Loading: 2.3s
Compiling shaders: 8.20s
Scene Setup: 0.5s

this would give a quick and easy way to start optimizing the load times, without having to do performance tests on various devices, multiple times, comparing load times etc.

i think this would be a valuable feature.

the gltf material seems to indroduce some differences in shading, though.
maybe there it is mixed differently, or it uses a different gamma, but we are not able to reproduce the same strength of ao in the browser, as we have in eevee.

we made a short script, that list materials which could be converted to gltf2 materials:

import bpy

# count the materials using gltf2 compatible
gltf2count = 0
print("gltf2 compatible material enabled on:")

for m in bpy.data.materials:
    if m.v3d.gltf_compat:
        gltf2count += 1
        print(m)
        
print("gltf2 Materials: " + str(gltf2count))
print("")

# find simple materials, that could be converted to gltf2
print("simple materials to consider making gltf2:")
for m in bpy.data.materials:
    
    # get the material node tree
    nt = m.node_tree
    node_count = 0
    
    # loop all nodes
    for n in nt.nodes:
        # do not count output nodes, or principled BSDF nodes
        if n.type != "BSDF_PRINCIPLED" and n.type != "OUTPUT_MATERIAL":
            node_count += 1
            
    # if the material has less than 2 remaining node, list it in the console
    if node_count < 2 and not m.v3d.gltf_compat:
        print(m)

it is very basic for now, but helped us quickly find the materials that can be converted without visual changes.

so it seems like the amount of materials / shaders accounts to ~1/3 of our loading time… that is heavy, but understandable, since we had 102 materials going.

this will give us room for improvement now.

still, a feature that simply prints out the contributing factors/times in the console could save loads of time in finding the shortcomings

ah, i see.

we were trying to access it via
app.camera.controls.enableZoom
where it does not exist.

but
app.controls.enableZoom
works just fine!