# SPDX-License-Identifier: GPL-2.0-only """ A 3D font helper """ bl_info = { "name": "Font3D", "author": "Jakob Schlötter, Studio Pointer*", "version": (0, 0, 1), "blender": (4, 1, 0), "location": "wherever it may be", "description": "Does Font3D stuff", "category": "Typography", } # make sure that modules are reloadable # when registering # handy for development # first import dependencies for the method import importlib # then import dependencies for our addon if "bpy" in locals(): importlib.reload(Font) importlib.reload(utils) importlib.reload(butils) else: from .common import Font from .common import utils from . import butils import bpy import math import mathutils import io import functools from bpy.types import Panel from bpy.app.handlers import persistent from random import uniform import time import datetime import os import re class SharedVariables(): fonts = Font.fonts def __init__(self, **kv): self.__dict__.update(kv) def getPreferences(context): preferences = context.preferences return preferences.addons[__name__].preferences shared = SharedVariables() class FONT3D_addonPreferences(bpy.types.AddonPreferences): """Font3D Addon Preferences These are the preferences at Edit/Preferences/Add-ons""" bl_idname = __name__ def get_default_assets_dir(): return bpy.utils.user_resource( 'DATAFILES', path=f"{__name__}", create=True) def on_change_assets_dir(self, context): if not os.path.isdir(self.assets_dir): butils.ShowMessageBox( title=f"{__name__} Warning", icon="ERROR", message=("Chosen directory does not exist.", "Please, reset to default, create it or chose another one.")) elif not os.access(self.assets_dir, os.W_OK): butils.ShowMessageBox( title=f"{__name__} Warning", icon="ERROR", message=("Chosen directory is not writable.", "Please reset to default or chose another one.")) else: shared.paths["assets"] = self.assets_dir print(f"{__name__}: change assets_dir to {self.assets_dir}") assets_dir: bpy.props.StringProperty( name="Assets Folder", subtype='DIR_PATH', default=get_default_assets_dir(), update=on_change_assets_dir, ) def draw(self, context): layout = self.layout layout.label(text="Directory for storage of fonts and other assets:") layout.prop(self, "assets_dir") class FONT3D_OT_Font3D(bpy.types.Operator): """Font 3D""" bl_idname = "font3d.font3d" bl_label = "Font 3D" bl_options = {'REGISTER', 'UNDO'} def execute(self, context): global shared print("Font3d execute()") scene = bpy.context.scene file_dir = scene.font3d.file_dir print(f"file_dir: {file_dir}") return {'FINISHED'} class FONT3D_settings(bpy.types.PropertyGroup): font_path: bpy.props.StringProperty(name="Font path", description="Where is the font", default="", maxlen=1024, subtype="FILE_PATH") import_infix: bpy.props.StringProperty(name="Font name import infix", description="The infix which all font objects to import have", default="_NM_", maxlen=1024, ) test_text: bpy.props.StringProperty(name="Test Text", description="the text to test with", default="Hello", maxlen=1024, ) class FONT3D_available_font(bpy.types.PropertyGroup): font_name: bpy.props.StringProperty(name="whatever") #TODO: simply, merge, cut cut cut class FONT3D_data(bpy.types.PropertyGroup): available_fonts: bpy.props.CollectionProperty(type=FONT3D_available_font, name="name of the collection poporotery") active_font_index: bpy.props.IntProperty() class FONT3D_UL_fonts(bpy.types.UIList): def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index): split = layout.split(factor=0.3) split.label(text="Index: %d" % (index)) # custom_icon = "OUTLINER_OB_%s" % item.obj_type # split.prop(item, "name", text="", emboss=False, translate=False) split.label(text=f"{item.font_name}") # avoids renaming the item by accident def invoke(self, context, event): pass class FONT3D_PT_panel(bpy.types.Panel): bl_label = "Panel for Font3D" bl_category = "Font3D" bl_space_type = "VIEW_3D" bl_region_type = "UI" def draw(self, context): global shared layout = self.layout wm = context.window_manager scene = context.scene font3d = scene.font3d font3d_data = scene.font3d_data layout.label(text="Load FontFile:") layout.row().prop(font3d, "font_path") layout.row().operator('font3d.loadfont', text='Load Font') layout.label(text="Available Fonts") layout.template_list("FONT3D_UL_fonts", "", font3d_data, "available_fonts", font3d_data, "active_font_index") layout.label(text='DEBUG') layout.row().prop(font3d, "test_text") layout.row().operator('font3d.testfont', text='Test Font') layout.label(text="font creation") layout.row().prop(font3d, "import_infix") layout.row().operator('font3d.create_font_from_objects', text='Create Font') layout.row().separator() layout.row().operator('font3d.save_font_to_file', text='Save Font To File') layout.row().operator('font3d.toggle_font3d_collection', text='Toggle Collection') layout.label(text='DEBUG END') class FONT3D_OT_LoadFont(bpy.types.Operator): """Load Font 3D""" bl_idname = "font3d.loadfont" bl_label = "Load Font" bl_options = {'REGISTER', 'UNDO'} def execute(self, context): global shared scene = bpy.context.scene # print(f"loading da font at path {scene.font3d.font_path}") if not os.path.exists(scene.font3d.font_path): butils.ShowMessageBox( title=f"{__name__} Warning", icon="ERROR", message=f"We believe the font path ({scene.font3d.font_path}) does not exist.", ) return {'CANCELLED'} currentObjects = [] for ob in bpy.data.objects: currentObjects.append(ob.name) bpy.ops.import_scene.gltf(filepath=scene.font3d.font_path) newObjects = [] fontcollection = bpy.data.collections.new("Font3D") scene.collection.children.link(fontcollection) font = { "name": "", "glyphs": [] } for o in bpy.data.objects: if o.name not in currentObjects: if (o.parent == None): font['name'] = o.name elif o.parent.name.startswith("glyphs"): font['glyphs'].append(o) newObjects.append(o.name) scene.collection.objects.unlink(o) fontcollection.objects.link(o) try: shared.fonts except: shared.fonts = {} shared.fonts[font['name']] = Font.Font() shared.fonts[font['name']]['faces']['regular'] = font return {'FINISHED'} class FONT3D_OT_TestFont(bpy.types.Operator): """Test Font 3D""" bl_idname = "font3d.testfont" bl_label = "Test Font" bl_options = {'REGISTER', 'UNDO'} def execute(self, context): global shared scene = bpy.context.scene selected = bpy.context.view_layer.objects.active if selected: font_name = "NM_Origin" font_face = "Tender" offset = mathutils.Vector((0.0, 0.0, 0.0)) advance = 0 for i, c in enumerate(scene.font3d.test_text): glyph_id = c glyph = Font.get_glyph(font_name, font_face, glyph_id) if glyph == None: self.report({'ERROR'}, f"Glyph not found for {font_name} {font_face} {glyph_id}") continue elif glyph.type == "CURVE": print("is curve") glyph_advance = (-1 * glyph.bound_box[0][0] + glyph.bound_box[4][0]) * 0.01 offset.x = advance ob = bpy.data.objects.new(f"{glyph_id}", glyph.data) ob.location = selected.location + offset ob.scale = (0.01, 0.01, 0.01) selected.users_collection[0].objects.link(ob) ob.parent = selected advance = advance + glyph_advance else: butils.ShowMessageBox( title="No object selected", message=( "Please select an object.", "It will be used to put the type on.", "You little piece of shit :)"), icon='GHOST_ENABLED') return {'FINISHED'} class FONT3D_OT_ToggleFont3DCollection(bpy.types.Operator): """Toggle Font3D Collection""" bl_idname = "font3d.toggle_font3d_collection" bl_label = "Toggle Collection visibility" bl_options = {'REGISTER', 'UNDO'} def execute(self, context): scene = context.scene fontcollection = bpy.data.collections.get("Font3D") if fontcollection is None: self.report({'INFO'}, f"{bl_info['name']}: There is no collection") elif scene.collection.children.find(fontcollection.name) < 0: scene.collection.children.link(fontcollection) self.report({'INFO'}, f"{bl_info['name']}: show collection") else: scene.collection.children.unlink(fontcollection) self.report({'INFO'}, f"{bl_info['name']}: hide collection") return {'FINISHED'} class FONT3D_OT_SaveFontToFile(bpy.types.Operator): """Save font to file""" bl_idname = f"{__name__}.save_font_to_file" bl_label = "Save Font" bl_options = {'REGISTER', 'UNDO'} file_path = "whoopwhoop" def execute(self, context): global shared scene = bpy.context.scene font3d_data = scene.font3d_data font3d = scene.font3d fontcollection = bpy.data.collections.get("Font3D") # needed to restore current state later fontcollection_was_linked = False previous_objects = [] fontcollection_objects = [] # hide fontcollection if fontcollection is None: self.report({'INFO'}, f"{bl_info['name']}: There is no collection") return {'CANCELLED'} elif scene.collection.children.find(fontcollection.name) > 0: scene.collection.children.unlink(fontcollection) fontcollection_was_linked = True # collect and hide previous objects for o in scene.objects: previous_objects.append(o) scene.collection.objects.unlink(o) # show fontcollection # if scene.collection.children.find(fontcollection.name) < 0: # scene.collection.children.link(fontcollection) # link fontcollection for o in fontcollection.objects: fontcollection_objects.append(o) fontcollection.objects.unlink(o) scene.collection.objects.link(o) # get save data selected_font = font3d_data.available_fonts[font3d_data.active_font_index] if selected_font == "": butils.ShowMessageBox("Warning", 'ERROR', "no font selected") return {'CANCELLED'} print(selected_font.font_name) # save as gltf bpy.ops.export_scene.gltf( filepath="/home/jrkb/Downloads/toast/maker.gltf", check_existing=False, export_format='GLTF_SEPARATE', export_extras=True, export_hierarchy_full_collections=True, use_active_collection_with_nested=True, ) # restore from previous state def restore(): for o in scene.objects: scene.collection.objects.unlink(o) for o in previous_objects: scene.collection.objects.link(o) for o in fontcollection_objects: fontcollection.objects.link(o) if fontcollection_was_linked: scene.collection.children.link(fontcollection) bpy.app.timers.register(restore, first_interval=5) return {'FINISHED'} class FONT3D_OT_CreateFontFromObjects(bpy.types.Operator): """Create Font from open objects""" bl_idname = "font3d.create_font_from_objects" bl_label = "Create Font" bl_options = {'REGISTER', 'UNDO'} def execute(self, context): global shared scene = bpy.context.scene font3d = scene.font3d font3d_data = scene.font3d_data fontcollection = bpy.data.collections.get("Font3D") if fontcollection is None: fontcollection = bpy.data.collections.new("Font3D") ifxsplit = font3d.import_infix.split('_') font_name = f"{ifxsplit[1]}_{ifxsplit[2]}" face_name = ifxsplit[3] added_font = False font3d_data.available_fonts.clear() Font.fonts = {} currentObjects = [] for o in bpy.data.objects: if o.name not in currentObjects: if font3d.import_infix in o.name: uc = o.users_collection regex = f"{font3d.import_infix}(.)*" name = re.sub(regex, "", o.name) glyph_id = "unknown" if len(name) == 1: glyph_id = name elif name in Font.name_to_glyph_d: glyph_id = Font.name_to_glyph_d[name] if glyph_id != "unknown": bpy.data.objects[o.name]["glyph"] = glyph_id butils.move_in_fontcollection( o, fontcollection, scene) Font.add_glyph( font_name, face_name, glyph_id, o) added_font = True #TODO: is there a better way to iterate over a CollectionProperty? 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 else: self.report({'INFO'}, f"did not understand glyph {name}") return {'FINISHED'} classes = ( FONT3D_addonPreferences, FONT3D_OT_Font3D, FONT3D_available_font, FONT3D_data, FONT3D_settings, FONT3D_UL_fonts, FONT3D_PT_panel, FONT3D_OT_TestFont, FONT3D_OT_LoadFont, FONT3D_OT_ToggleFont3DCollection, FONT3D_OT_SaveFontToFile, FONT3D_OT_CreateFontFromObjects, ) def register(): for cls in classes: bpy.utils.register_class(cls) bpy.types.Scene.font3d = bpy.props.PointerProperty(type=FONT3D_settings) bpy.types.Scene.font3d_data = bpy.props.PointerProperty(type=FONT3D_data) print(f"REGISTER {bl_info['name']}") # would love to properly auto start this, but IT DOES NOT WORK # if load_handler not in bpy.app.handlers.load_post: # bpy.app.handlers.load_post.append(load_handler) def unregister(): # would love to properly auto start this, but IT DOES NOT WORK # if load_handler in bpy.app.handlers.load_post: # bpy.app.handlers.load_post.remove(load_handler) for cls in classes: bpy.utils.unregister_class(cls) del bpy.types.Scene.font3d del bpy.types.Scene.font3d_data print(f"UNREGISTER {bl_info['name']}") if __name__ == '__main__': register()