615 lines
23 KiB
Python
615 lines
23 KiB
Python
import bpy
|
|
import mathutils
|
|
import queue
|
|
import importlib
|
|
import os
|
|
|
|
# then import dependencies for our addon
|
|
if "Font" in locals():
|
|
importlib.reload(Font)
|
|
else:
|
|
from .common import Font
|
|
|
|
if "utils" in locals():
|
|
importlib.reload(utils)
|
|
else:
|
|
from .common import utils
|
|
|
|
execution_queue = queue.Queue()
|
|
|
|
# This function can safely be called in another thread.
|
|
# The function will be executed when the timer runs the next time.
|
|
def run_in_main_thread(function):
|
|
execution_queue.put(function)
|
|
|
|
def execute_queued_functions():
|
|
while not execution_queue.empty():
|
|
function = execution_queue.get()
|
|
function()
|
|
return 1.0
|
|
|
|
def apply_all_transforms(obj):
|
|
mb = obj.matrix_basis
|
|
if hasattr(obj.data, "transform"):
|
|
obj.data.transform(mb)
|
|
for c in obj.children:
|
|
c.matrix_local = mb @ c.matrix_local
|
|
obj.matrix_basis.identity()
|
|
|
|
def get_parent_collection_names(collection, parent_names):
|
|
for parent_collection in bpy.data.collections:
|
|
if collection.name in parent_collection.children.keys():
|
|
parent_names.append(parent_collection.name)
|
|
get_parent_collection_names(parent_collection, parent_names)
|
|
return
|
|
|
|
# Ensure it's a curve object
|
|
# TODO: no raising, please
|
|
def get_curve_length(curve_obj, resolution = -1):
|
|
total_length = 0
|
|
|
|
curve = curve_obj.data
|
|
|
|
# Loop through all splines in the curve
|
|
for spline in curve.splines:
|
|
total_length = total_length + spline.calc_length(resolution=resolution)
|
|
|
|
return total_length
|
|
|
|
def get_curve_line_lengths(curve_obj, resolution = -1):
|
|
lengths = []
|
|
for spline in curve_obj.data.splines:
|
|
lengths.append(spline.calc_length(resolution=resolution))
|
|
return lengths
|
|
|
|
def get_next_line_advance(curve_obj, current_advance, previous_glyph_advance, resolution = -1):
|
|
curve_line_lengths = get_curve_line_lengths(curve_obj, resolution)
|
|
total_length = 0
|
|
for cll in curve_line_lengths:
|
|
total_length += cll
|
|
if current_advance - previous_glyph_advance < total_length:
|
|
return total_length
|
|
return current_advance
|
|
|
|
def calc_point_on_bezier(bezier_point_1, bezier_point_2, t):
|
|
p1 = bezier_point_1.co
|
|
h1 = bezier_point_1.handle_right
|
|
p2 = bezier_point_2.co
|
|
h2 = bezier_point_2.handle_left
|
|
return ((1 - t)**3) * p1 + (3 * t * (1 - t)**2) * h1 + (3 * (t**2) * (1 - t)) * h2 + (t**3) * p2
|
|
|
|
# same in slightly more lines
|
|
# result is equal, performance minimally better perhaps?
|
|
# def calc_point_on_bezier(bezier_point_1, bezier_point_2, ratio):
|
|
# startPoint = bezier_point_1.co
|
|
# controlPoint1 = bezier_point_1.handle_right
|
|
# controlPoint2 = bezier_point_2.handle_left
|
|
# endPoint = bezier_point_2.co
|
|
|
|
# remainder = 1 - ratio
|
|
# ratioSquared = ratio * ratio
|
|
# remainderSquared = remainder * remainder
|
|
# startPointMultiplier = remainderSquared * remainder
|
|
# controlPoint1Multiplier = remainderSquared * ratio * 3
|
|
# controlPoint2Multiplier = ratioSquared * remainder * 3
|
|
# endPointMultiplier = ratioSquared * ratio
|
|
|
|
# return startPoint * startPointMultiplier + controlPoint1 * controlPoint1Multiplier + controlPoint2 * controlPoint2Multiplier + endPoint * endPointMultiplier
|
|
|
|
|
|
def calc_tangent_on_bezier(bezier_point_1, bezier_point_2, t):
|
|
p1 = bezier_point_1.co
|
|
h1 = bezier_point_1.handle_right
|
|
p2 = bezier_point_2.co
|
|
h2 = bezier_point_2.handle_left
|
|
return (
|
|
(-3 * (1 - t)**2) * p1 + (-6 * t * (1 - t) + 3 * (1 - t)**2) * h1 +
|
|
(-3 * (t**2) + 6 * t * (1 - t)) * h2 + (3 * t**2) * p2
|
|
).normalized()
|
|
|
|
from math import radians, sqrt, pi, acos
|
|
|
|
def align_rotations_auto_pivot(mask, input_rotations, vectors, factors, local_main_axis):
|
|
output_rotations = [mathutils.Matrix().to_3x3() for _ in range(len(input_rotations))]
|
|
|
|
for i in mask:
|
|
vector = mathutils.Vector(vectors[i]).normalized()
|
|
input_rotation = mathutils.Euler(input_rotations[i])
|
|
|
|
if vector.length < 1e-6:
|
|
output_rotations[i] = input_rotation.to_matrix()
|
|
continue
|
|
|
|
old_rotation = input_rotation.to_matrix()
|
|
old_axis = (old_rotation @ local_main_axis).normalized()
|
|
new_axis = vector
|
|
# rotation_axis = (-(old_axis) + new_axis).normalized()
|
|
rotation_axis = old_axis.cross(new_axis).normalized()
|
|
|
|
if rotation_axis.length < 1e-6:
|
|
# Vectors are linearly dependent, fallback to another axis
|
|
rotation_axis = (old_axis + mathutils.Matrix().col[2]).normalized()
|
|
|
|
if rotation_axis.length < 1e-6:
|
|
# This is now guaranteed to not be zero
|
|
rotation_axis = (-(old_axis) + mathutils.Matrix().col[1]).normalized()
|
|
|
|
# full_angle = radians(sqrt((4 * pow(input_rotation.to_quaternion().dot(mathutils.Quaternion(vectors[i].normalized())), 2) - 3)))
|
|
# dot = old_axis.dot(new_axis)
|
|
# normalized_diff = (old_axis - new_axis).normalized()
|
|
# full_angle = acos(min((old_axis * new_axis + normalized_diff.dot(2)).length, 1))
|
|
full_angle = old_axis.angle(new_axis)
|
|
angle = factors[i] * full_angle
|
|
|
|
rotation = mathutils.Quaternion(rotation_axis, angle).to_matrix()
|
|
new_rotation_matrix = old_rotation @ rotation
|
|
output_rotations[i] = new_rotation_matrix
|
|
|
|
return [mat.to_4x4() for mat in output_rotations]
|
|
|
|
def calc_bezier_length(bezier_point_1, bezier_point_2, resolution=20):
|
|
step = 1/resolution
|
|
previous_p = bezier_point_1.co
|
|
length = 0
|
|
for i in range(-1, resolution):
|
|
t = (i + 1) * step
|
|
p = calc_point_on_bezier(bezier_point_1, bezier_point_2, t)
|
|
length += (p - previous_p).length
|
|
previous_p = p
|
|
return length
|
|
|
|
def calc_point_on_bezier_spline(bezier_spline_obj,
|
|
distance,
|
|
output_tangent = False,
|
|
resolution_factor = 1.0):
|
|
# what's the point of just one point
|
|
# assert len(bezier_spline_obj.bezier_points) >= 2
|
|
# however, maybe let's have it not crash and do this
|
|
if len(bezier_spline_obj.bezier_points) < 1:
|
|
print("butils::calc_point_on_bezier_spline: whoops, no points. panicking. return 0,0,0")
|
|
if output_tangent:
|
|
return mathutils.Vector((0,0,0)), mathutils.Vector((1,0,0))
|
|
else:
|
|
return mathutils.Vector((0,0,0))
|
|
if len(bezier_spline_obj.bezier_points) == 1:
|
|
p = bezier_spline_obj.bezier_points[0]
|
|
travel = (p.handle_left - p.co).normalized() * distance
|
|
if output_tangent:
|
|
tangent = mathutils.Vector((1,0,0))
|
|
return travel, tangent
|
|
else:
|
|
return travel
|
|
|
|
if distance <= 0:
|
|
p = bezier_spline_obj.bezier_points[0]
|
|
travel = (p.co - p.handle_left).normalized() * distance
|
|
location = p.co + travel
|
|
if output_tangent:
|
|
p2 = bezier_spline_obj.bezier_points[1]
|
|
tangent = calc_tangent_on_bezier(p, p2, 0)
|
|
return location, tangent
|
|
else:
|
|
return location
|
|
|
|
beziers = []
|
|
lengths = []
|
|
total_length = 0
|
|
n_bezier_points = len(bezier_spline_obj.bezier_points)
|
|
for i in range(0, len(bezier_spline_obj.bezier_points) - 1):
|
|
bezier = [ bezier_spline_obj.bezier_points[i],
|
|
bezier_spline_obj.bezier_points[i + 1] ]
|
|
length = calc_bezier_length(bezier[0],
|
|
bezier[1],
|
|
int(bezier_spline_obj.resolution_u * resolution_factor))
|
|
total_length += length
|
|
beziers.append(bezier)
|
|
lengths.append(length)
|
|
# if total_length > distance:
|
|
# break
|
|
|
|
iterated_distance = 0
|
|
for i in range(0, len(beziers)):
|
|
if iterated_distance + lengths[i] > distance:
|
|
distance_on_bezier = (distance - iterated_distance)
|
|
d = distance_on_bezier / lengths[i]
|
|
# print(f"i: {i}, d: {d}, distance_on_bezier: {distance_on_bezier}, distance: {distance}")
|
|
location = calc_point_on_bezier(beziers[i][0],
|
|
beziers[i][1],
|
|
d)
|
|
if output_tangent:
|
|
tangent = calc_tangent_on_bezier(beziers[i][0],
|
|
beziers[i][1],
|
|
d)
|
|
return location, tangent
|
|
else:
|
|
return location
|
|
iterated_distance += lengths[i]
|
|
# if we are here, the point is outside the spline
|
|
last_i = len(beziers) - 1
|
|
p = beziers[last_i][1]
|
|
travel = (p.handle_right - p.co).normalized() * (distance - total_length)
|
|
location = p.co + travel
|
|
if output_tangent:
|
|
tangent = calc_tangent_on_bezier(beziers[last_i][0],
|
|
p,
|
|
1)
|
|
return location, tangent
|
|
else:
|
|
return location
|
|
|
|
|
|
def calc_point_on_bezier_curve(bezier_curve_obj,
|
|
distance,
|
|
output_tangent = False,
|
|
resolution_factor = 1.0):
|
|
curve = bezier_curve_obj.data
|
|
|
|
# Loop through all splines in the curve
|
|
total_length = 0
|
|
for i, spline in enumerate(curve.splines):
|
|
resolution = int(spline.resolution_u * resolution_factor)
|
|
length = spline.calc_length(resolution=resolution)
|
|
if total_length + length > distance or i == len(curve.splines) - 1:
|
|
return calc_point_on_bezier_spline(spline,
|
|
(distance - total_length),
|
|
output_tangent,
|
|
resolution_factor)
|
|
total_length += length
|
|
|
|
# TODO: can this fail?
|
|
|
|
|
|
# def get_objects_by_name(name, startswith="", endswith=""):
|
|
# return [obj for obj in bpy.context.scene.objects if obj.name.startswith(startswith) and if obj.name.endswith(endswith)]
|
|
|
|
def find_objects_by_name(
|
|
objects,
|
|
equals="",
|
|
contains="",
|
|
startswith="",
|
|
endswith=""):
|
|
# handle equals
|
|
if equals != "":
|
|
index = objects.find(equals)
|
|
if index >= 0:
|
|
return [objects[index]]
|
|
return []
|
|
# handle others is more permissive
|
|
return [obj for obj in objects if obj.name.startswith(startswith) and obj.name.endswith(endswith) and obj.name.find(contains) >= 0]
|
|
|
|
def find_objects_by_custom_property(
|
|
objects,
|
|
property_name="",
|
|
property_value=""):
|
|
return [obj for obj in objects if property_name in obj and obj[property_name] == property_value]
|
|
|
|
def turn_collection_hierarchy_into_path(obj):
|
|
parent_collection = obj.users_collection[0]
|
|
parent_names = []
|
|
parent_names.append(parent_collection.name)
|
|
get_parent_collection_names(parent_collection, parent_names)
|
|
parent_names.reverse()
|
|
return '\\'.join(parent_names)
|
|
|
|
def find_font_object(fontcollection, font_name):
|
|
fonts = find_objects_by_custom_property(fontcollection.objects,
|
|
"is_font",
|
|
True)
|
|
for font in fonts:
|
|
if font["font_name"] == font_name and font.parent == None:
|
|
return font
|
|
return None
|
|
|
|
def find_font_face_object(font_obj, face_name):
|
|
faces = find_objects_by_custom_property(font_obj.children,
|
|
"is_face",
|
|
True)
|
|
for face in faces:
|
|
if face["face_name"] == face_name:
|
|
return face
|
|
return None
|
|
|
|
def move_in_fontcollection(obj, fontcollection, allow_duplicates=False):
|
|
|
|
# parent nesting structure
|
|
# the font object
|
|
font_obj = find_font_object(fontcollection,
|
|
obj["font_name"])
|
|
if font_obj == None:
|
|
font_obj = bpy.data.objects.new(obj["font_name"], None)
|
|
font_obj.empty_display_type = 'PLAIN_AXES'
|
|
fontcollection.objects.link(font_obj)
|
|
|
|
# ensure custom properties are set
|
|
font_obj["font_name"] = obj["font_name"]
|
|
font_obj["is_font"] = True
|
|
|
|
# the face object as a child of font object
|
|
face_obj = find_font_face_object(font_obj,
|
|
obj["face_name"])
|
|
if face_obj == None:
|
|
face_obj = bpy.data.objects.new(obj["face_name"], None)
|
|
face_obj.empty_display_type = 'PLAIN_AXES'
|
|
face_obj["is_face"] = True
|
|
fontcollection.objects.link(face_obj)
|
|
|
|
# ensure custom properties are set
|
|
face_obj["face_name"] = obj["face_name"]
|
|
face_obj["font_name"] = obj["font_name"]
|
|
|
|
if face_obj.parent != font_obj:
|
|
face_obj.parent = font_obj
|
|
|
|
# create glyphs if it does not exist
|
|
glyphs_objs = find_objects_by_name(face_obj.children, startswith="glyphs")
|
|
if len(glyphs_objs) <= 0:
|
|
glyphs_obj = bpy.data.objects.new("glyphs", None)
|
|
glyphs_obj.empty_display_type = 'PLAIN_AXES'
|
|
fontcollection.objects.link(glyphs_obj)
|
|
glyphs_obj.parent = face_obj
|
|
elif len(glyphs_objs) > 1:
|
|
print(f"found more glyphs objects than expected")
|
|
|
|
# now it must exist
|
|
glyphs_obj = find_objects_by_name(face_obj.children, startswith="glyphs")[0]
|
|
glyphs_obj["face_name"] = obj["face_name"]
|
|
glyphs_obj["font_name"] = obj["font_name"]
|
|
|
|
def get_hash(o):
|
|
return hash(tuple(tuple(v.co) for v in o.data.vertices ))
|
|
|
|
for other_obj in find_objects_by_custom_property(glyphs_obj.children, "glyph", obj["glyph"]):
|
|
if get_hash(other_obj) == get_hash(obj) and not allow_duplicates:
|
|
return other_obj
|
|
|
|
# and now parent it!
|
|
if obj.parent != glyphs_obj:
|
|
obj.parent = glyphs_obj
|
|
|
|
for c in obj.users_collection:
|
|
c.objects.unlink(obj)
|
|
if fontcollection.objects.find(obj.name) < 0:
|
|
fontcollection.objects.link(obj)
|
|
|
|
return obj
|
|
|
|
def load_font_from_filepath(filepath):
|
|
if not filepath.endswith(".glb") and not filepath.endswith(".gltf"):
|
|
ShowMessageBox(f"{bl_info['name']} Font loading error", 'ERROR', f"Filepath({filepath}) is not a *.glb or *.gltf file")
|
|
return False
|
|
|
|
font3d_data = bpy.context.scene.font3d_data
|
|
allObjectsBefore = []
|
|
for ob in bpy.data.objects:
|
|
allObjectsBefore.append(ob.name)
|
|
|
|
bpy.ops.import_scene.gltf(filepath=filepath)
|
|
|
|
fontcollection = bpy.data.collections.get("Font3D")
|
|
if fontcollection is None:
|
|
fontcollection = bpy.data.collections.new("Font3D")
|
|
|
|
remove_list = []
|
|
all_objects = []
|
|
for o in bpy.data.objects:
|
|
all_objects.append(o)
|
|
print("all objects", len(all_objects))
|
|
for o in all_objects:
|
|
if o.name not in allObjectsBefore:
|
|
# must be new
|
|
if ("glyph" in o.keys()
|
|
and "face_name" in o.keys()
|
|
and "font_name" in o.keys()):
|
|
print("adding glyph", o)
|
|
glyph_id = o["glyph"]
|
|
font_name = o["font_name"]
|
|
face_name = o["face_name"]
|
|
glyph_obj = move_in_fontcollection(
|
|
o,
|
|
fontcollection)
|
|
Font.add_glyph(
|
|
font_name,
|
|
face_name,
|
|
glyph_id,
|
|
glyph_obj)
|
|
if glyph_obj != o:
|
|
remove_list.append(o)
|
|
|
|
found = False
|
|
for f in font3d_data.available_fonts.values():
|
|
if f.font_name == font_name:
|
|
found = True
|
|
break
|
|
if not found:
|
|
f = font3d_data.available_fonts.add()
|
|
f.font_name = font_name
|
|
print(f"{__name__} added {font_name}")
|
|
else:
|
|
remove_list.append(o)
|
|
print("add to remove list", o)
|
|
for o in remove_list:
|
|
bpy.data.objects.remove(o, do_unlink=True)
|
|
print("removed",o)
|
|
print(f"{__name__}: loaded fonts")
|
|
|
|
def getPreferences(context):
|
|
preferences = context.preferences
|
|
return preferences.addons['font3d'].preferences
|
|
|
|
# clear available fonts
|
|
def clear_available_fonts():
|
|
bpy.context.scene.font3d_data.available_fonts.clear()
|
|
|
|
def load_available_fonts():
|
|
preferences = getPreferences(bpy.context)
|
|
|
|
currentObjects = []
|
|
for ob in bpy.data.objects:
|
|
currentObjects.append(ob.name)
|
|
|
|
print(f"assets folder: {preferences.assets_dir}")
|
|
font_dir = f"{preferences.assets_dir}/fonts"
|
|
for file in os.listdir(font_dir):
|
|
if file.endswith(".glb") or file.endswith(".gltf"):
|
|
font_path = os.path.join(font_dir, file)
|
|
load_font_from_filepath(font_path)
|
|
|
|
def ShowMessageBox(title = "Message Box", icon = 'INFO', message=""):
|
|
|
|
"""Show a simple message box
|
|
|
|
taken from `Link here <https://blender.stackexchange.com/questions/169844/multi-line-text-box-with-popup-menu>`_
|
|
|
|
:param title: The title shown in the message top bar
|
|
:type title: str
|
|
:param icon: The icon to be shown in the message top bar
|
|
:type icon: str
|
|
:param message: lines of text to display, a.k.a. the message
|
|
:type message: str or (str, str, ..)
|
|
|
|
TIP: Check `Link blender icons <https://docs.blender.org/api/current/bpy_types_enum_items/icon_items.html>`_ for icons you can use
|
|
TIP: Or even better, check `Link this addons <https://docs.blender.org/manual/en/latest/addons/development/icon_viewer.html>`_ to also see the icons.
|
|
|
|
usage:
|
|
.. code-block:: python
|
|
myLines=("line 1","line 2","line 3")
|
|
butils.ShowMessageBox(message=myLines)
|
|
|
|
or:
|
|
.. code-block:: python
|
|
butils.ShowMessageBox(title="",message=("AAAAAH","NOOOOO"),icon=)
|
|
|
|
"""
|
|
myLines=message
|
|
def draw(self, context):
|
|
if isinstance(myLines, str):
|
|
self.layout.label(text=myLines)
|
|
elif hasattr(myLines, "__iter__"):
|
|
for n in myLines:
|
|
self.layout.label(text=n)
|
|
bpy.context.window_manager.popup_menu(draw, title = title, icon = icon)
|
|
|
|
def set_text_on_curve(text_properties):
|
|
mom = text_properties.text_object
|
|
if mom.type != "CURVE":
|
|
return False
|
|
|
|
regenerate = False
|
|
glyph_objects = []
|
|
for g in text_properties.glyphs:
|
|
glyph_objects.append(g.glyph_object)
|
|
|
|
# check if perhaps one glyph was deleted
|
|
if (type(g.glyph_object) == type(None)
|
|
or type(g.glyph_object.parent) == type(None)
|
|
or g.glyph_object.parent.users_collection != g.glyph_object.users_collection):
|
|
regenerate = True
|
|
|
|
if len(text_properties.text) != len(text_properties.glyphs):
|
|
regenerate = True
|
|
|
|
# if we regenerate.... delete objects
|
|
if regenerate:
|
|
context_override = bpy.context.copy()
|
|
context_override["selected_objects"] = list(glyph_objects)
|
|
with bpy.context.temp_override(**context_override):
|
|
bpy.ops.object.delete()
|
|
|
|
# remove deleted objects
|
|
# this is necessary
|
|
for g in glyph_objects:
|
|
if type(g) != type(None):
|
|
bpy.data.objects.remove(g, do_unlink=True)
|
|
|
|
text_properties.glyphs.clear()
|
|
|
|
#TODO: fix selection with context_override
|
|
previous_selection = bpy.context.selected_objects
|
|
bpy.ops.object.select_all(action='DESELECT')
|
|
selected_objects = []
|
|
|
|
curve_length = get_curve_length(mom)
|
|
advance = 0
|
|
glyph_advance = 0
|
|
is_command = False
|
|
for i, c in enumerate(text_properties.text):
|
|
if c == '\\':
|
|
is_command = True
|
|
continue
|
|
if is_command:
|
|
if c == 'n':
|
|
next_line_advance = get_next_line_advance(mom, advance, glyph_advance)
|
|
if advance == next_line_advance:
|
|
# self.report({'INFO'}, f"would like to add new line for {text_properties.text} please")
|
|
print(f"would like to add new line for {text_properties.text} please")
|
|
advance = next_line_advance
|
|
continue
|
|
is_command = False
|
|
glyph_id = c
|
|
|
|
glyph = Font.get_glyph(text_properties.font_name,
|
|
text_properties.font_face,
|
|
glyph_id)
|
|
|
|
ob = None
|
|
if regenerate:
|
|
if glyph == None:
|
|
# self.report({'ERROR'}, f"Glyph not found for {font_name} {font_face} {glyph_id}")
|
|
print(f"Glyph not found for {font_name} {font_face} {glyph_id}")
|
|
continue
|
|
|
|
ob = bpy.data.objects.new(f"{glyph_id}", glyph.data)
|
|
ob['linked_textobject'] = text_properties.text_id
|
|
else:
|
|
ob = text_properties.glyphs[i]['glyph_object']
|
|
|
|
distribution_type = 'CALCULATE'
|
|
if distribution_type == 'FOLLOW_PATH':
|
|
ob.constraints.new(type='FOLLOW_PATH')
|
|
ob.constraints["Follow Path"].target = mom
|
|
ob.constraints["Follow Path"].use_fixed_location = True
|
|
ob.constraints["Follow Path"].offset_factor = advance / curve_length
|
|
ob.constraints["Follow Path"].use_curve_follow = True
|
|
ob.constraints["Follow Path"].forward_axis = "FORWARD_X"
|
|
ob.constraints["Follow Path"].up_axis = "UP_Y"
|
|
elif distribution_type == 'CALCULATE':
|
|
location, tangent = calc_point_on_bezier_curve(mom, advance, True)
|
|
ob.location = mom.matrix_world @ location
|
|
mask = [0]
|
|
input_rotations = [mathutils.Vector((0.0, 0.0, 0.0))]
|
|
vectors = [tangent]
|
|
factors = [1.0]
|
|
local_main_axis = mathutils.Vector((1.0, 0.0, 0.0))
|
|
motor = align_rotations_auto_pivot(mask,
|
|
input_rotations,
|
|
vectors,
|
|
factors,
|
|
local_main_axis)
|
|
if ob.rotation_mode != 'QUATERNION':
|
|
ob.rotation_mode = 'QUATERNION'
|
|
q = mathutils.Quaternion()
|
|
q.rotate(text_properties.orientation)
|
|
ob.rotation_quaternion = (mom.matrix_world @ motor[0] @ q.to_matrix().to_4x4()).to_quaternion()
|
|
|
|
scalor = 0.001
|
|
|
|
glyph_advance = (-1 * glyph.bound_box[0][0] + glyph.bound_box[4][0]) * scalor + text_properties.letter_spacing
|
|
|
|
ob.scale = (scalor, scalor, scalor)
|
|
|
|
advance = advance + glyph_advance
|
|
|
|
if regenerate:
|
|
mom.users_collection[0].objects.link(ob)
|
|
glyph_data = text_properties.glyphs.add()
|
|
glyph_data.glyph_id = glyph_id
|
|
glyph_data.glyph_object = ob
|
|
glyph_data.letter_spacing = 0
|
|
ob.select_set(True)
|
|
|
|
if regenerate:
|
|
mom.select_set(True)
|
|
bpy.context.view_layer.objects.active = mom
|
|
bpy.ops.object.parent_set(type='OBJECT')
|
|
|
|
return True
|