From e19bf2d07048bf1b6a9c636380c52f44336c81e8 Mon Sep 17 00:00:00 2001 From: yum Date: Tue, 24 Mar 2026 00:16:32 -0700 Subject: Pull in letter grid gimmick from 2ner --- Scripts/gen_atlas | 421 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 421 insertions(+) create mode 100755 Scripts/gen_atlas (limited to 'Scripts/gen_atlas') diff --git a/Scripts/gen_atlas b/Scripts/gen_atlas new file mode 100755 index 0000000..a3fac72 --- /dev/null +++ b/Scripts/gen_atlas @@ -0,0 +1,421 @@ +#!/usr/bin/env -S uv run --script +# /// script +# requires-python = ">=3.10" +# dependencies = ["Pillow"] +# /// + +import argparse +import subprocess +import os +import sys +import json +from PIL import Image, ImageDraw +import random + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +MSDF_REPO = "https://github.com/Chlumsky/msdf-atlas-gen.git" +MSDF_DIR = os.path.join(SCRIPT_DIR, "msdf-atlas-gen") +MSDF_BUILD_DIR = os.path.join(MSDF_DIR, "build") + +def get_msdf_binary(): + """Return path to msdf-atlas-gen binary, building from source if needed.""" + if sys.platform == "win32": + binary = os.path.join(MSDF_BUILD_DIR, "bin", "Debug", "msdf-atlas-gen.exe") + else: + binary = os.path.join(MSDF_BUILD_DIR, "bin", "msdf-atlas-gen") + if os.path.isfile(binary): + return binary + print("msdf-atlas-gen not found, acquiring from source...") + if not os.path.isdir(MSDF_DIR): + subprocess.run( + ["git", "clone", "--recursive", MSDF_REPO, MSDF_DIR], + check=True, + ) + else: + print("Source directory exists, skipping clone.") + os.makedirs(MSDF_BUILD_DIR, exist_ok=True) + subprocess.run( + [ + "cmake", "..", + "-DCMAKE_BUILD_TYPE=Release", + "-DMSDF_ATLAS_USE_VCPKG=OFF", + "-DMSDF_ATLAS_USE_SKIA=OFF", + "-DMSDF_ATLAS_NO_ARTERY_FONT=ON", + ], + cwd=MSDF_BUILD_DIR, + check=True, + ) + subprocess.run( + ["cmake", "--build", ".", "--config", "Release", "-j", str(os.cpu_count() or 4)], + cwd=MSDF_BUILD_DIR, + check=True, + ) + if not os.path.isfile(binary): + # Try Release subdir on Windows + alt = os.path.join(MSDF_BUILD_DIR, "bin", "Release", "msdf-atlas-gen.exe") + if os.path.isfile(alt): + return alt + raise FileNotFoundError(f"Build succeeded but binary not found at {binary}") + return binary + +# Define the character ranges we want to include +CHAR_RANGES = [ + (32, 126), # Printable ASCII + # Add more ranges here as needed, e.g.: + (0x0080, 0x00ff), # latin + (0x0100, 0x017f), # latin + (0x0180, 0x024f), # latin + (0x0250, 0x02af), # ipa extensions + (0x0370, 0x03ff), # greek and coptic + (0x0400, 0x04ff), # cyrillic + (0x0500, 0x052f), # cyrillic supplement + (0x0530, 0x058f), # armenian + (0x0590, 0x05ff), # hebrew + (0x0600, 0x06ff), # arabic +] + +def calculate_grid_size(char_ranges): + """Calculate the smallest square grid that fits the highest character code""" + max_char = max(end for _, end in char_ranges) + grid_size = 1 + while grid_size * grid_size < max_char: + grid_size += 1 + return grid_size + +ATLAS_TYPES = [ + "hardmask", # binary image + "softmask", # anti-aliased image + "sdf", # signed distance field + "psdf", # perpendicular distance field + "msdf", # multi-channel signed distance field + "mtsdf" # combined MSDF and true SDF +] + +def calculate_font_size(resolution, base_size=None): + """Calculate the font size based on resolution, scaling from 512 resolution""" + if base_size is None: + base_size = 32 # Default size at 512 resolution + return (base_size * resolution) // 512 + +def generate_atlas(font_path, resolution, draw_grid=False, type="msdf", font_size=None): + """Generates a font atlas using various distance field techniques. + + This function creates a font atlas using msdf-atlas-gen, then rearranges the + characters to include gaps for non-printable characters. The output is saved + as 'atlas.png' in the current directory. + + Args: + font_path (str): Path to the input font file (.ttf/.otf) + resolution (int): Width and height of the output atlas in pixels + draw_grid (bool, optional): If True, draws red grid lines on the output. + Defaults to False. + type (str, optional): Atlas type to generate. See ATLAS_TYPES. + font_size (int, optional): Base font size in pixels at 512 resolution. + Will be scaled for other resolutions. + + Returns: + bool: True if atlas generation succeeded, False if an error occurred. + + Raises: + subprocess.CalledProcessError: If msdf-atlas-gen fails to execute. + """ + # Get font name from path + font_name = os.path.splitext(os.path.basename(font_path))[0] + + # Calculate grid size based on character ranges + grid_size = calculate_grid_size(CHAR_RANGES) + cell_size = resolution // grid_size + + # Calculate font size if not specified, scaling from 512 resolution + if font_size is None: + font_size = calculate_font_size(resolution) + else: + font_size = calculate_font_size(resolution, font_size) + + # Convert character ranges to command-line format + chars_str = ", ".join(f"[{start}, {end}]" for start, end in CHAR_RANGES) + + # Update the output filename to include resolution + output_filename = f"atlas_{font_name}_{resolution}_{type}" + + cmd = [ + get_msdf_binary(), + "-font", font_path, + "-type", type, + "-format", "png", + "-imageout", f"{output_filename}.png", + "-size", str(font_size), + "-pxrange", "4", + "-dimensions", str(resolution), str(resolution), + "-chars", chars_str, + "-uniformgrid", + "-uniformcols", str(grid_size), + "-uniformcell", str(cell_size), str(cell_size), + "-errorcorrection", "auto-full", + "-scanline", + #"-angle", "15d", + "-edgecoloring", "distance" + ] + + try: + print("Running msdf-atlas-gen...") + print("Command:", end=" ") + for arg in cmd: + if arg.startswith('-'): + print(f"\n {arg}", end=" ") + else: + print(arg, end=" ") + print() + result = subprocess.run(cmd, check=True, capture_output=True, text=True) + + # Print the output + if result.stdout: + print("msdf-atlas-gen output:") + print(result.stdout) + + # Rearrange the atlas to include gaps for non-printable characters + print("Rearranging atlas...") + rearrange_atlas(resolution, cell_size, cell_size, draw_grid, type, font_name) + + # Generate or update Unity meta file + generate_unity_meta(output_filename, resolution) + return True + except subprocess.CalledProcessError as e: + print(f"Error generating atlas: {e}") + print(f"Error output: {e.stderr}") + return False + +def draw_grid_lines(image, resolution): + """Draw red grid lines on the image""" + draw = ImageDraw.Draw(image) + grid_size = calculate_grid_size(CHAR_RANGES) + + # Draw vertical lines + for x in range(grid_size): + line_x = x * resolution // grid_size + draw.line([(line_x, 0), (line_x, resolution-1)], fill=(255, 0, 0), width=1) + + # Draw horizontal lines + for y in range(grid_size): + line_y = y * resolution // grid_size + draw.line([(0, line_y), (resolution-1, line_y)], fill=(255, 0, 0), width=1) + + # Draw the final borders + draw.line([(resolution-1, 0), (resolution-1, resolution-1)], fill=(255, 0, 0), width=1) + draw.line([(0, resolution-1), (resolution-1, resolution-1)], fill=(255, 0, 0), width=1) + +def rearrange_atlas(resolution, cell_width, cell_height, draw_grid=False, type="msdf", font_name=""): + """Rearrange the atlas to include gaps for non-printable characters""" + # Update input and output filenames to match generate_atlas format + input_filename = f"atlas_{font_name}_{resolution}_{type}.png" + original = Image.open(input_filename) + new_atlas = Image.new('RGBA', (resolution, resolution), (0, 0, 0, 255)) + + grid_size = calculate_grid_size(CHAR_RANGES) + cell_size = resolution // grid_size + + # Track current position in the source atlas + source_index = 0 + + # Process each character range + for start, end in CHAR_RANGES: + for ascii_code in range(start, end + 1): + # Calculate source position (original atlas) + source_x = (source_index % grid_size) * cell_size + source_y = (source_index // grid_size) * cell_size + + # Calculate target position (new atlas) + target_x = ((ascii_code + 1) % grid_size) * cell_size + target_y = ((ascii_code + 1) // grid_size) * cell_size + + # Extract and paste the glyph + glyph = original.crop(( + source_x, + source_y, + source_x + cell_size, + source_y + cell_size + )) + new_atlas.paste(glyph, (target_x, target_y)) + source_index += 1 + + # Draw the grid lines only if requested + if draw_grid: + draw_grid_lines(new_atlas, resolution) + + # Calculate actual used dimensions + used_resolution = cell_size * grid_size + # Crop to used dimensions and resize back to requested resolution + used_atlas = new_atlas.crop((0, 0, used_resolution, used_resolution)) + final_atlas = used_atlas.resize((resolution, resolution), Image.LANCZOS) + + # Save with the same filename format (no change needed since input/output are the same) + final_atlas.save(input_filename) + print("Atlas rearranged successfully!") + +def generate_unity_meta(basename, resolution): + """Generate or update Unity meta file for the atlas texture.""" + meta_path = f"{basename}.png.meta" + existing_guid = None + + # Try to read existing GUID if meta file exists + if os.path.exists(meta_path): + with open(meta_path, 'r') as f: + for line in f: + if 'guid: ' in line: + existing_guid = line.split('guid: ')[1].strip() + break + + # Generate new GUID if none exists + guid = existing_guid or ''.join('%x' % random.randrange(16) for _ in range(32)) + + meta_template = f'''fileFormatVersion: 2 +guid: {guid} +TextureImporter: + internalIDToNameTable: [] + externalObjects: {{}} + serializedVersion: 12 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + flipGreenChannel: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + ignoreMipmapLimit: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: {resolution} + textureSettings: + serializedVersion: 2 + filterMode: 1 + aniso: 1 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 0 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {{x: 0.5, y: 0.5}} + spritePixelsToUnits: 100 + spriteBorder: {{x: 0, y: 0, z: 0, w: 0}} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + swizzle: 50462976 + cookieLightType: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: {resolution} + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 2 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + ignorePlatformSupport: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: {resolution} + resizeAlgorithm: 0 + textureFormat: 3 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 1 + ignorePlatformSupport: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Android + maxTextureSize: {resolution} + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + ignorePlatformSupport: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + nameFileIdTable: {{}} + mipmapLimitGroupName: + pSDRemoveMatte: 0 + userData: + assetBundleName: + assetBundleVariant: +''' + + with open(meta_path, 'w') as f: + f.write(meta_template) + +def main(): + parser = argparse.ArgumentParser(description='Generate a font atlas using msdf-atlas-gen') + parser.add_argument('font_path', help='Path to the font file (.ttf/.otf)') + parser.add_argument('resolution', type=int, help='Total atlas resolution (width=height)') + parser.add_argument('--grid', type=bool, default=False, help='Draw grid lines on the output atlas') + parser.add_argument('--type', type=str, default="msdf", choices=ATLAS_TYPES, + help='Type of atlas to generate') + parser.add_argument('--font-size', type=int, help='Base font size in pixels at 512 resolution. Will be scaled for other resolutions.') + args = parser.parse_args() + + # Verify font file exists + if not os.path.isfile(args.font_path): + print(f"Error: Font file not found at {args.font_path}") + return + + generate_atlas(args.font_path, args.resolution, draw_grid=args.grid, type=args.type, font_size=args.font_size) + +if __name__ == "__main__": + main() -- cgit v1.2.3