View "data-normal" of Hotspots in Blender

[Trolli991]

Hello,
As the title already says, I try to read out or set the "data-normal" coordinates in Blender. The goal is to create the hotspots in Blender through Vertex Point with the help of Python scripts.

When I place an example hotspot on an object using the Model viewer editor on the internet, I can easily find the data position stored in the generated HTML file in blender (Its simply the Vertext coordinates in meters). However, I have no idea where to find the data normal coordinates.

EDIT: Via the "Spreadsheet" I can display the normal data of a face under "Face". This however does not work with single vertex point. Would this even be possible? Can a Single Point have a normal data?

Thanks in advance

[elalish]

I'm not sure either, but Blender certainly has a concept of normals. Our editor uses face normals specifically (the cross product of the three vertex coordinates of the triangle).

[elalish]

If you don't want to use the normal of the face you're part of, you could also interpolate the nearest vertex normals, if there are any specified. Or you can just pick an arbitrary direction that works well (toward the camera?).

[Trolli991]

I have actually had similar ideas. First I worked with a system that emulated the normal data via the direction vector between a camera and the empty. But this worked only sometimes and I could not find the error. I am now working with a method where the nearest surface normal of the nearest object is copied as normal data.

So I have a blender scene with one or more objects and position my emptys around the object. the emptys should be named hotspot-xx. If you add a "|" in the name and another text behind it, the text will be used as label for the later hotspot. So for example: "hotspot-07 | Astronaut Helmet"

Attached the code, if someone needs a similar solution

import bpy
from mathutils import Vector

def get_nearest_face_normal(empty_obj):
    # Position of Empty Object
    empty_pos = empty_obj.location
    
    # Calculate nearest Object
    nearest_mesh_obj = None
    min_distance = float('inf')
    
    for obj in bpy.data.objects:
        if obj.type == 'MESH':
            # Calculate Distanc e between Empty-Object and Mesh-Object
            distance = (empty_pos - obj.location).length
            
            # Updating the next mesh object
            if distance < min_distance:
                min_distance = distance
                nearest_mesh_obj = obj
    
    if nearest_mesh_obj is None:
        print("No nearest mesh object was found")
        return None
    
    # Access to the nearest mesh object
    mesh_obj = nearest_mesh_obj
    mesh = mesh_obj.data
    mesh.update()
    
    # Calculation of the nearest face
    nearest_face = None
    min_face_distance = float('inf')
    
    for face in mesh.polygons:
        # Calculation of the average position of the face
        face_center = Vector()
        for vert_index in face.vertices:
            vertex = mesh.vertices[vert_index]
            face_center += vertex.co
        face_center /= len(face.vertices)
        
        # Calculation of the distance between Empty object and Face
        distance = (empty_pos - face_center).length
        
        # Update the next Face
        if distance < min_face_distance:
            min_face_distance = distance
            nearest_face = face
    
    if nearest_face is not None:
        # Output of the normal data of the nearest face in the desired format
        normal_data = nearest_face.normal
        formatted_normal = "{:.4f}m {:.4f}m {:.4f}m".format(normal_data.x, normal_data.z, -normal_data.y)
        return formatted_normal
    
    print("No nearest Face was found")
    return None


# Main Programm
output_strings = []

# Retrieve active scene object
scene = bpy.context.scene

# Go through and sort all Empty objects with "hotspot-".
hotspot_objects = sorted([obj for obj in scene.objects if obj.type == 'EMPTY' and obj.name.startswith("hotspot-")], key=lambda obj: obj.name)

# For each hotspot-empty determine the associated normal data and perform the arithmetic operations
for obj in hotspot_objects:
    obj_name = obj.name
    obj_addition = ""
    
    # Check if there is a "|" symbol in the name
    if "|" in obj_name:
        obj_name, obj_addition = obj_name.split("|", 1)
    
    # Determine the normal data for the current hotspot empty
    normal_data = get_nearest_face_normal(obj)
    if normal_data:
        output_strings.append('<button class="Hotspot" slot="{}"'.format(obj_name[:-1]))
        
        # Output coordinates of the Empty object
        coords = " ".join(f"{c:.6f}m" for c in (obj.location.x, obj.location.z, -obj.location.y))
        hotspot_output = 'data-position="{}"'.format(coords)
        output_strings.append(hotspot_output)
        
        # Output normal data
        normal_output = 'data-normal="{}"'.format(normal_data)
        output_strings.append(normal_output)
        
        output_strings.append('data-visibility-attribute="visible"><div class="HotspotAnnotation">'+obj_addition[1:]+'</div></button>')
        output_strings.append('\n')    
    else:
        print("No normal data found for the hotspot empty '{}'.".format(obj_name))

# Output all Strings
output = " ".join(output_strings)
print(output)