Skip to content

Feature Catalog

Jump to bottom
Gustavo edited this page Oct 11, 2026 · 1 revision

LegendaryTools Feature Catalog

240 functional features in 18 categories, summarized from package source (2026-10-11). Supporting interfaces, generated overloads, drawers and examples are grouped with their owning feature.

Start here · Common combinations · Scope and source coverage

Async and Startup

Waiting, background execution, connectivity and dependency-driven initialization.

  • AsyncWait — Cancellation-aware waits for time, frames, conditions, coroutines, Tasks and Unity async operations, with coroutine and optional UniTask backends.
  • ThreadedRoutine — Runs IEnumerator work on a background thread and switches to Unity execution through explicit yield markers.
  • Main Thread Actions — Action extension overloads enqueue callbacks through UnityHub for main-thread execution.
  • Internet Connection Checks — Replaceable ScriptableObject connectivity checks using Unity reachability, HTTP or ping.
  • Maestro Task Orchestration — Runs tasks with dependencies, timeout tracking and optional internet requirements.
  • GameInitialization — Builds a game startup sequence from configurable initialization steps and a step listing.
  • Maestro Graph Editor — Authors initialization-step relationships using the reusable node editor.

Collections and Algorithms

Reusable maps, buffers, serialized values, graphs, trees and pathfinding.

  • Bictionary — Maintains paired key-to-value and value-to-key dictionary lookups.
  • OneToOneMap — Manages unique pairings between two sets of keys.
  • OneToManyMap — Stores one key associated with multiple values.
  • ManyToManyMap — Stores relations where both sides can have multiple associations.
  • MappedList — Combines ordered list access with a lookup map.
  • CircularBuffer — Keeps a bounded sequence in reusable circular storage.
  • Priority Queues — Provides priority-ordered queues, including the specialized queue used by AStar.
  • MovingAverage — Calculates a rolling average of recent numeric samples.
  • SerializableDictionary — Stores dictionary entries in a Unity-serializable form with a custom Inspector drawer.
  • SerializableType — Persists CLR type references and supplies a filtered type picker.
  • SerializedDateTime — Wraps DateTime for Unity serialization and Inspector date editing.
  • SerializedTimeSpan — Wraps TimeSpan for Unity serialization and Inspector duration editing.
  • ScriptableObjectContainer — Returns cloned data from a ScriptableObject container and sets the clone's parent reference.
  • Graphs V1 — Linked and hierarchical graph structures represent connected nodes and graph nesting.
  • Tree V1 — Branch-based tree structure in the original graph API.
  • Graphs V2 — Interface-based nodes and connections with a reusable graph implementation.
  • Tree V2 — Parent-child tree nodes expose a reusable hierarchy API.
  • BinaryTree — Two-child node structure with binary-tree operations.
  • SelfBalanceTree — Self-balancing binary-search tree with rotation-based rebalancing.
  • MultiParentTree — Hierarchy whose nodes may belong to multiple parents.
  • Nested Types — ScriptableObject taxonomy with multiple parents, cached hierarchy queries and cycle checks.
  • AStar Pathfinding — Generic A* search uses a supplied neighbor and heuristic contract.

Spatial and Geometry

Spatial queries, large-world coordinates, pointer raycasts and procedural voxels.

  • Hex Grid — Hex and fractional coordinates, orientation, layout, map and map-view helpers.
  • Octree — Partitions three-dimensional space into a tree for spatial queries.
  • QuadTree — Partitions two-dimensional space into a tree for spatial queries.
  • Hierarchical Spatial Hash Grid — Quantized sparse indexing separates static and dynamic entries and supports filtered spatial queries.
  • Spatial Hash Scene Integration — Bodies, volumes and a system wrapper register scene bounds, stable IDs and dynamic updates.
  • Global Coordinates — Integer global positions, vectors and bounds convert to Unity-local coordinates through a configurable world scale.
  • Floating Origin — Recenters a local Unity world around an anchor while preserving its global location.
  • ScreenToWorldInfo — Casts screen-space positions into 3D or 2D physics and exposes hit position and normal.
  • DynamicCube Voxel Meshing — Builds voxel grids with internal-face culling, greedy quad merging, tiled UVs and optional mesh colliders.

Deterministic Computing

Fixed-point arithmetic, reproducible containers, rollback, replay and network sessions.

  • Fixed-Point Scalars — Signed and unsigned 32/64-bit fixed-point numbers share configurable precision, rounding, overflow and special-value policies.
  • FixedMath — Deterministic fixed-point math exposes arithmetic helpers, roots, trigonometry and other functions with status-returning variants.
  • Fixed Vectors — Fixed64-based 2D/3D vectors provide geometry, normalization, interpolation and movement helpers.
  • Fixed-Point Network Codecs — Scalar and vector codecs support fixed-width, varint and range-based bit-packed payloads with compatibility profiles.
  • FixedRandom — Philox-based deterministic random streams expose ranges, chances, dice, sampling, shuffling and state capture/restore.
  • Deterministic Weighted Selection — Builds fixed-point weight tables and chooses weighted indexes using FixedRandom.
  • Deterministic Spatial Random — Samples fixed-point points inside or on circles, spheres, boxes, rectangles and triangles.
  • FixedRandom Network State — Encodes random state and negotiates algorithm, sampler and numeric compatibility descriptors.
  • Fixed-Point Unity Integration — Managed/Burst batch operations, Native random APIs, vector conversion and serialized vector wrappers bridge fixed-point code to Unity.
  • Deterministic Sequence Collections — Managed and Native arrays, cells, lists, queues, deques, stacks and ring buffers expose defined order and allocation policies.
  • Deterministic Hash Collections — Dictionary and HashSet variants preserve insertion order with explicit deterministic equality/hash policies.
  • Deterministic Sorted Collections — SortedList uses ordered arrays; SortedDictionary and SortedSet use indexed AVL storage, with Managed and Native variants.
  • Deterministic Priority Queue — Minimum-priority queue preserves FIFO order for equal priorities and snapshots its ordering counter.
  • Deterministic BitSet — Indexed bit storage supports counting and finding active bits in both memory backends.
  • Deterministic SlotMap — Generational handles identify pooled slots with defined reuse and snapshot behavior.
  • Deterministic SparseSet — Dense component storage uses explicit swap-removal and offers entity-ID ordering.
  • Deterministic LinkedList — Pool-backed linked nodes use generational handles and preserve their links in snapshots.
  • Deterministic MultiMap — Keys and each key's values retain insertion order through shared Managed/Native algorithms.
  • Deterministic Graphs — Mutable Managed and Native graph storage uses stable graph handles and deterministic topology operations.
  • Frozen Deterministic Graphs — Frozen graph variants and canonical bindings provide immutable graph topology for queries and transport.
  • Deterministic Graph Algorithms — Reachability, breadth/depth-first traversal, cycle detection, topological order and component analysis use explicit scratch/output storage.
  • Deterministic Collection Snapshots — Bounded snapshot slots and leases capture/restore collections with full-copy or copy-on-write storage.
  • Canonical Checkpoints and Codecs — Versioned binary readers/writers, field codecs and canonical collection bindings preserve logical state and validate data before import.
  • Fixed-Point Deterministic Adapters — Fixed numeric policies, RNG state codecs and compatibility fingerprints integrate FixedPoint with deterministic containers/runtime.
  • Deterministic Runtime Context — Selects an explicit backend and a compatible memory factory for host-side orchestration.
  • Deterministic State Registry — Registers state by stable IDs, freezes compatibility signatures and captures/restores canonical world checkpoints.
  • Deterministic World History — Retains bounded world boundaries as full checkpoints, keyframes/deltas or shared canonical pages.
  • Deterministic Input History — Tracks immutable real inputs, predicted inputs and historical player participation by tick.
  • Deterministic Command Buffers — Producer partitions merge commands in a defined total order; the Native variant supplies job writers and dependency checks.
  • Lockstep and Rollback Simulation — A tick runner advances lockstep or predicted simulation, restores checkpoints, resimulates and confirms progress.
  • Deterministic Event Ledger — Tracks speculative events, retractions and once-only confirmed delivery.
  • Deterministic Replay Archive — Stores real inputs, hashes and versioned checkpoints with restoration and seeking.
  • Deterministic Network Sessions — Coordinates inputs, commits, late join, reconnect and migration around the simulation runtime.
  • Deterministic Raft Coordination — Elections, replicated logs, snapshots and joint membership changes coordinate session consensus.
  • Deterministic Transport and Loopback Network — Datagram contracts and a loopback network simulate delivery, loss, duplication and delay.

Architecture and State

Pooling, services, observable data, MVC and versioned state machines.

  • Object Pooling — Pools plain objects and Unity GameObjects through poolable contracts and reusable instance APIs.
  • ServiceLocator — Registers services by type and exposes shared service lookup.
  • Singletons — Generic, MonoBehaviour and ScriptableObject singleton bases provide shared-instance patterns and related attributes.
  • MVC Framework — Model contracts and view/controller bases pair through a manager and model factories.
  • Observable Values — Generic and typed values raise old/new change notifications; AccessorObservable wraps external getters/setters.
  • ObservableList — List operations notify additions, updates, removals and clearing, including affected indexes.
  • ObservableDictionary — Dictionary operations publish entry-change notifications and support Inspector editing.
  • StateMachine V1 — Original linked-graph state machine supports triggers, transition arguments and recorded state history.
  • HardStateMachine V2 — Enum-backed states expose entry/update/exit callbacks and optional transition permission checks.
  • AdvancedStateMachine V2 — Graph-based states use typed parameters, any-state transitions and composable boolean/numeric/trigger conditions.
  • Command Contracts — ICommand exposes Execute/Unexecute on a receiver; IAsyncCommand provides Task-based asynchronous execution.
  • Unity Serialization Bases — UnityBehaviour and UnityObject select standard Unity bases or Odin serialized bases through a compile symbol.

ScriptableObject Architecture

Asset-based variables, references, events, variants and persistence.

Binding and Scripting

Observable bindings, Inspector-authored data binding, expressions and embedded scripting.

  • Reactive Component Bindings — Observable-to-component bindings cover TMP text/input/dropdown, sliders, toggles, images, scrollbars, CanvasGroups and transforms.
  • Fluent Reactive Bindings — Builder APIs configure component bindings with direction, formatting and control-specific options.
  • Reactive Binding Lifetime — Disposable handles, anchors and update drivers provide suspend/resume, resync and automatic owner-lifecycle cleanup.
  • Reactive Bindings Debugger — Editor window inspects registered live bindings and their diagnostic metadata.
  • ViewDataBinder — Inspector or runtime-authored member bindings synchronize one-way, reverse or two-way with selectable update timing.
  • ViewDataEventBinder — Polls source changes, evaluates AND/OR comparison clauses and invokes UnityEvents or public Task-returning methods.
  • ViewDataListBinder — Projects IEnumerable data into keyed prefab items with filtering, sorting, paging, pooling and optional ScrollRect virtualization.
  • Binding Profiles and Contexts — Reusable profile assets and named hierarchy contexts resolve model/view roots and support runtime overrides.
  • Binding Converters — Reusable converter assets bridge numeric/string/bool/null/enum values; eligible converters also support reverse conversion.
  • Binding Formatters — Composite string formatting combines multiple sources with optional culture settings and an extensible formatter registry.
  • Binding Conditions and Recovery Policies — Per-binding conditions, conflict/write rules, fallbacks, null handling, missing-endpoint recovery and error policies control synchronization.
  • Binding Backends and Execution — Replaceable member/source backends and instance resolvers use cached execution plans and a shared update scheduler.
  • Binding Accessor Code Generation — Editor/build scanning generates member accessors and eligible typed direct plans, with reflection fallback for unsupported paths.
  • Binding Inspector and Diagnostics — Member/type pickers, value previews, status indicators, extension slots and runtime counters support binding authoring and diagnosis.
  • Generic Expression Engine — Parses, compiles, caches and evaluates numeric/boolean expressions with arithmetic, comparison, logical, assignment and function nodes.
  • Expression Providers and Scopes — Dictionary/instance providers and relation-aware named scopes resolve expression variables across logical owners.
  • MiniCSharp Interpreter — Executes a C#-like language with variables, functions, control flow, exceptions and reflection-based object/type interop.
  • MiniCSharp Unity Hosting — A component forwards Unity callbacks to script functions; RuntimeScriptAsset stores source and caches compiled scripts.
  • MiniCSharp Type Access Policy — Type, name, namespace and assembly blacklist rules gate reflection interop; the interpreter also controls automatic AppDomain type resolution.

Persistence and Time

Save/load providers, serialization, encryption helpers and synchronized offline time.

  • Persistence — Typed, ID-based data tables support set/get/remove, version metadata, callbacks and save/load operations with pluggable providers.
  • Persistence Serialization Providers — Provider assets select JSON, XML or binary serialization, with optional Odin/Nido implementations and Unity converters.
  • Persistence Disk Storage — Storage abstraction and DiskStorage read/write a configured Unity file path.
  • Persistence AES Encryption — Replaceable AES encryption provider supplies the optional encryption stage in the persistence pipeline.
  • GZip and Base64 Helpers — Compression and Base64 utilities support persistence byte/string transformations.
  • FlatDataSerializer — Flattens public members of nested objects/collections into typed paths and tables, then reconstructs them through configurable factories/converters.
  • Serialization Helpers — Standalone XML/binary and optional Odin helpers serialize values and files.
  • RSA Security Helpers — RSA key import/export and typed, byte and file encryption/decryption helpers wrap the platform cryptography API.
  • UnityFilePath — Builds file paths from Unity root locations, subfolders, filename and extension.
  • Chronos Time and Offline Progress — Initializes and synchronizes UTC time, tracks trusted status and records elapsed time across close, pause and focus changes.
  • Chronos Time Providers — Ordered fallback providers supply system time, TimeAPI.io, WorldTimeAPI or editor-controlled simulated time.
  • Chronos Trusted State and Policies — Security/offline policies, signed persisted state and synchronization cooldowns govern time trust and tamper status.
  • Chronos Time Control Editor — Editor bridge/window inspect Chronos and control simulated time through the time-machine provider.

Gameplay and Attributes

Actor lifecycles, inventory quantities, cargo and two attribute-system generations.

  • Actor Lifecycle System — Plain C# actors possess/eject MonoBehaviour bodies, create/destroy GameObjects and register actors by type.
  • Configurable Actors — Typed actor/body pairs carry an ActorConfig asset into the runtime actor on possession.
  • Poolable Actors — Actor subclasses create and release Unity bodies through Pool.
  • Actor Asset Loading — A type-to-loader configuration resolves actor prefabs and supports asynchronous body loading/preload setup.
  • Inventory — Generic item-to-float-quantity storage supports addition, removal, lookup, transfer and change events.
  • ScriptableObjectInventory — Inventory wrapper exposes quantity-based storage through a ScriptableObject asset.
  • Cargo and Containers — Capacity-limited cargo groups inventory containers and transfers available quantities between cargos or inventories.
  • Attribute System V1 — Original configurable attributes support types, conditions, modifier operators and propagation rules.
  • Attribute Entities V1 — Entity configs/data, a manager and factory assemble runtime entities with V1 attributes.
  • Attribute Definitions and Instances V2 — Typed integer/float/flag definitions and runtime instances support visibility, base values, clamping and fixed/dynamic limits.
  • Attribute Entities and Scopes V2 — Entity definitions/runtime entities own attributes and expose a scope tree plus expression variable providers.
  • Attribute Modifiers V2 — Coordinator/applier/session APIs support direct or reactive modifiers with sorting, stacking and missing-target policies.
  • Expression-Based Modifier Conditions — A generic-expression evaluator and compiled-expression cache determine modifier eligibility with entity scopes.

Audio

Pooled audio playback, authored settings, playlists and UI sounds.

  • Bragi Audio Hub — Spawns pooled AudioHandlers and plays configs/groups at a position or parent with several group playback modes.
  • Audio Configs and Settings — Asset-based clips/loaders and playback settings configure volume, pitch, looping, spatial behavior and fades.
  • Audio Groups — Weighted config groups play randomly, sequentially, in a chain or simultaneously.
  • AudioHandler — Owns an AudioSource with playback state, fade controls and play/finish/stop events; disposal returns it to the pool.
  • Jukebox Playlists — Sequential/random/reseeded playlists support looping, navigation, mute, pause and automatic continuation.
  • UIAudioTrigger — Maps pointer, selection, drag, lifecycle and custom-string events to audio configs with optional parallel-play prevention.

Assets and Identity

Asset-loading strategies, unique references, persistent IDs and custom tags.

  • Asset Provider and Loaders — Loader assets unify hard references, Resources and optional Addressables behind load operations and async loading.
  • ResourcePathReference — Serializable Resources-path reference includes an Inspector drawer for asset selection.
  • IdentifiedBehaviour — Component base exposes generated identity and identity-change behavior.
  • UniqueBehaviour and References — Unique components, serialized references and object listings work with editor validation and a reference picker.
  • UniqueScriptableObject — ScriptableObject base assigns identity to assets and participates in uniqueness tooling.
  • Tags and Tag Filters — Asset-defined tags, a taggable contract and filters model multiple custom classifications.

Unity Runtime Helpers

Unity lifecycle dispatch, filtered logging, transform helpers and sensors.

  • UnityHub — Central dispatch exposes Unity loop/lifecycle callbacks and queued main-thread actions.
  • Filtered Debugger — Type/category filtering configuration controls custom logging output and formatting.
  • FollowTransform — Follows position/rotation with offsets, thresholds, smoothing and Update/LateUpdate selection.
  • LookAt — Faces a target using selectable axes, axis constraints and optional reverse facing.
  • ProximityDetector — Generic trigger-based detection tracks compatible nearby components and entry/exit behavior.
  • VisibilityDetector — Renderer visibility callbacks expose visible state and change notifications.

UI and Navigation

Screen/pop-up flow, dynamic lists, drag-and-drop and reusable visual components.

  • ScreenFlow Navigation — Config-driven screens and popup stacks use queued transitions, history, back behavior, scene entries and asset loading.
  • Screen Views and Controllers — Screen bases, generic/animated variants and view-controller contracts carry arguments and transition lifecycle behavior.
  • Popup Views and Controllers — Popup bases, animated variants, typed arguments and background/transition policies integrate modal views with ScreenFlow.
  • ScreenFlow UI Triggers and Back Rules — Scene/UI triggers issue configured flow commands while screen rules determine back-navigation behavior.
  • ScreenFlow Editor Setup — Editor actions create flow canvases/config assets and inspect screen-flow definitions.
  • CircularScrollView — Repositions scrolling items in a loop and exposes selected-item changes.
  • DynamicScrollView — Generic ScrollRect view creates/removes visible data items and supports refresh and scroll-to operations.
  • ScrollRect Viewport Utilities — Shared helpers calculate expanded viewport bounds and visible uniform-item ranges.
  • GameObjectListing — Generic data-to-prefab listing creates initialized views, filters data and removes generated items.
  • FieldSync — Reflection-based field/property synchronization links an origin and destination in edit and play modes, with a custom Inspector.
  • UI Drag and Drop — UIDrag/UIDrop coordinate pointer drags, slot acceptance, snapping, ownership and invalid-drop behavior.
  • Proximity UI — Pairs proximity detection with UIFollowTransform views and UI-created/removed events.
  • UIFollowTransform — Projects a target transform into a configured canvas with camera and offset controls.
  • UIGradient — Applies a four-corner bilinear color gradient through a UI mesh effect.
  • UILineConnector — Creates dynamic Image-based lines between RectTransforms with thickness, order, optional lifetime and pooling.
  • UIPanel — CanvasGroup wrapper controls alpha, interaction and raycasts, with optional selectable disabling.
  • UISafeArea — Adjusts RectTransform anchors for device safe areas, screen changes and optional pixel offsets.

Math and Extensions

Color/mesh/camera helpers and concise extensions for common C# and Unity tasks.

  • Enum and Flag Utilities — Enum extensions and FlagUtil validate values and test/add/remove enum or numeric flags.
  • Color and HSV Utilities — Color interpolation helpers and an HSV value type support RGB/HSV manipulation.
  • CurveUtil — Evaluates cubic spline interpolation between scalar control values.
  • MathUtil — Geometry intersections, random circle points and Fibonacci helpers supplement common math tasks.
  • MeshUtil — Creates polygon/convex/hex meshes, welds vertices, orders points and simplifies shapes.
  • Camera Framing — CameraUtil frames a GameObject or bounds for a chosen view.
  • PrintSaver Screenshots — Component saves screenshots with generated identifiers and configured capture behavior.
  • Dictionary Extensions — Adds update-or-insert, key/value extraction and weighted random selection helpers.
  • Collection Extensions — Helpers shuffle, swap, rotate, resize, query, clone and modify arrays/lists/sets.
  • Deep Clone and Equality — Generic helpers perform deep cloning and deep comparison.
  • Numeric Extensions — Adds range remapping, approximate comparison and compact float formatting.
  • Sorting Extensions — Provides HeapSort and Timsort over lists with configurable comparers.
  • String Naming Extensions — Converts camel-case names to constants and normalizes enum identifiers.
  • Task Extensions — FireAndForget observes task failure handling through a small convenience extension.
  • Type and Reflection Extensions — Caches/discovers CLR types and checks constructors, attributes, type families and Unity serializability.
  • Unity Extensions — Component/UI, bounds, animation, snapping, gizmo, prefab/scene and dirty-state helpers extend Unity APIs.
  • Editor Asset Search Extensions — Finds nearby/config assets, searches by type/name and resolves script asset paths.
  • Date and Time Extensions — Formats TimeSpan values and checks whether DateTimes share a day.

Asset and Content Editors

Reference analysis, content authoring, UI asset tools and object navigation.

  • AssetGuidMapper — Indexes GUID references in Unity serialized files and maintains forward/reverse lookup data.
  • Asset Navigator — Window navigates recently selected assets with history and search controls.
  • Reference Tracker — Searches serialized object/asset references within selectable scopes and groups matching usages.
  • Missing Reference Scanner — Scans Unity content for unresolved serialized references and missing scripts.
  • Orphan Asset Scanner — Analyzes asset references and candidate roots to report potentially unreferenced assets.
  • UI Texture Size Optimizer — Scans UI texture usage/layout, estimates useful imported sizes and previews/applies importer changes with report export.
  • ScriptableObject Browser — Searches and browses ScriptableObject assets by type and other filters.
  • Multi-Asset ScriptableObject Editor — Edits multiple ScriptableObjects in a table with shared fields and resizable rows/columns.
  • Spreadsheet Importer — Maps CSV columns to individual ScriptableObject assets or in-asset collections, including spreadsheet URL/Google access workflows.
  • UI Sprite Palette — Thumbnail palette and drag/drop handlers support browsing and applying UI sprite assets.
  • Scene UI Objects Tagger — Editor action tags eligible UI objects in the scene.
  • Asset and Prefab Icons — Custom icon generation, stores, project drawing and prefab preview caching synchronize asset visuals.
  • Editor Object Navigation — Context actions copy GameObject hierarchy paths and ping selected objects/assets.

Code and Automation Editors

Code generation, analysis, aggregation, clipboard workflows and serialized-data transfers.

  • Config-to-Enum Weaver — Generates enum mappings from configuration listings and runs configured weaving through editor/build hooks.
  • Config Name Constants Weaver — Generates names/constant listings from config assets through the shared weaving infrastructure.
  • Code Weaver Utilities — Writes enum/constant listings and UI binding class files, with property/event mapping helpers.
  • Command Generator — Reflects public methods of a selected class and generates command wrappers, including eligible async methods.
  • UI Component Field Generator — Generates component fields/binding code from a selected UI hierarchy.
  • MonoBehaviour to ScriptableObject Converter — Generates ScriptableObject-oriented code from selected MonoBehaviour source and supports the conversion workflow.
  • Copy Serialized Values — Editor window copies serialized values between compatible objects.
  • Reference Transfer — Reusable mappings transfer object references and component values between source/target hierarchies.
  • Serialized Snapshot Library — Captures component/GameObject serialized state and object references, previews differences and reapplies stored snapshots.
  • Manual Code Control — Monitors external code changes and exposes explicit import, compilation and reload actions when Auto Refresh is disabled.
  • Code Type Usage Analyzer — Scans source folders with text/regex analysis and reports declared-type usage per class and globally.
  • Scripts in Scene Analyzer — Reports scripts attached to scene objects and their usage.
  • Simple Code Aggregation — Folder-based editor utility concatenates source files into a single output.
  • CSharp Files Aggregator — Selectable file/folder aggregation combines dependency expansion, transforms, diagnostics, persistence and clipboard/output formatting.
  • CSharp Type Index — Roslyn scanners persist an index of declared types and their source paths with rebuild/settings actions.
  • Source Dependency Scanner — Roslyn-based analysis resolves type references and walks a filtered dependency graph to a configurable depth.
  • CSharp Implementation Stripper — Transforms source to reduce implementation bodies using configurable strip options and method-body modes.
  • DLL API Documentation Exporter — Reflects compiled assemblies and exports API documentation.
  • CSharp File Metrics — Tree view filters source files by size and comment-coverage metrics.
  • CSharp File Inventory — Editor menu lists project C# source files.
  • AI Clipboard Pipeline — Classifies clipboard C# or patches, resolves target paths, applies changes and tracks history/undo with compile gates.
  • Compilation Error Reports — Collects compiler errors into consolidated AI-friendly reports and records compilation outcome markers.
  • Roslyn Installer — Installs/reconciles or removes the LegendaryTools-managed Roslyn dependency copy.

Editor Interface and Diagnostics

Inspector authoring, hierarchy/graph views, project controls and performance analysis.

  • Inspector Attributes and Drawers — Attributes and drawers add method buttons/order, inline editors, min/max ranges, multilevel enums and observable-value editing.
  • Define Symbols Editor — Editor window manages scripting define symbols by build target/configuration.
  • GUIStyle Browser — Browses and previews available GUIStyle definitions.
  • Play Mode from Scene Zero — Editor hook starts Play Mode from the first configured build scene.
  • Hierarchy Decorator — Hierarchy drawers add configurable component icons, category/branch styling, breadcrumbs, toggles and tag/layer information.
  • Visual Graph Node Editor — Reusable graph editor provides node/edge models, canvas pan/grid/selection/resize, inspectors, clipboard, menus and toolbar extensions.
  • PlayerPrefs Editor — Tools inspect and edit PlayerPrefs entries.
  • Rendering Performance Hub — Editor dashboard gathers rendering settings and diagnostics and exposes related configuration shortcuts.
  • Renderer Audit — Scans scene renderers and groups resource/cost estimates around batching, instancing, shadows and transparency.
  • Domain Reload Analyzer — Captures reload logs/profiler markers, phase timelines and project findings with per-script/assembly attribution where available.

Developer Tooling

Source generators, samples, tests and standalone validation/benchmark harnesses.

  • Deterministic Source Generators — Python scripts generate collection policies, codecs, Native wrappers, graph bindings, state adapters and hash vectors.
  • Fixed-Point Source Generators — Python scripts generate scalar/vector/math/network/random/batch APIs and reference/replay corpora.
  • Tests and Validation Harnesses — Unity tests, Managed/Burst comparison suites, player corpora, standalone executables and snapshot benchmarks exercise library behavior.

Documentation snapshot: 2026-10-11

Tags: legendarytools/catalog

LegendaryTools repository · Home · Feature Catalog · Common Combinations

LegendaryTools

Categories

Clone this wiki locally