Super Level Optimizer 2

About Super Level Optimizer 2 – Unity Editor Tool & Plugin

Super Level Optimizer 2 Unity Asset Overview

Super Level Optimizer 2 operates as an automated scene graph processing tool designed to reduce rendering overhead by consolidating draw calls, batching static geometries, and optimizing complex material hierarchies. At its core, the architecture separates editor-time data processing from runtime execution through modular C# pipelines. By utilizing ScriptableObject data assets, optimization profiles can be authored, saved, and reused across multiple Unity scenes without mutating source prefabs.

Core Mesh Consolidation Engine

The mesh optimization sub-system relies on CombineInstance array allocations optimized to minimize garbage collection (GC) pressure. Static geometry grouped under scene containers is parsed according to sub-mesh indices, material references, and lightmap parameters. To handle dynamic lighting correctly, UV coordinates are recalculated using UV channel remapping utilities to prevent lightmap overlap and UV bleeding across combined geometries.

Vertex Animation Baking & Shader Pipeline

For skinned meshes and animated assets, Super Level Optimizer 2 implements a vertex animation baking system that converts bone hierarchies into 2D float textures. These textures are sampled directly by custom optimized shaders, allowing hundreds of animated characters or environmental objects to be rendered via GPU instancing without bone matrix evaluation on the CPU main thread. This offloads calculation overhead from the CPU to the GPU rasterizer.

using UnityEngine;
using System.Collections.Generic;

namespace SuperLevelOptimizer
{
    [CreateAssetMenu(fileName = "OptimizationProfile", menuName = "Tools/Level Optimizer Profile")]
    public class OptimizationProfile : ScriptableObject
    {
        [Header("Mesh Batching Settings")]
        public bool combineStaticMeshes = true;
        public bool generateSecondaryUVs = true;
        public LayerMask targetLayers;

        [Header("Atlas Configuration")]
        public int maxAtlasSize = 4096;
        public int texturePadding = 4;
        public TextureFormat atlasFormat = TextureFormat.RGBA32;

        [Header("Runtime Management")]
        public bool preserveLightmaps = true;
        public UnityEngine.Rendering.ShadowCastingMode shadowMode = UnityEngine.Rendering.ShadowCastingMode.On;
    }
}

Inspector Configuration & Workflow

The system provides a comprehensive workflow integrated into the Unity Editor via custom property drawers, custom EditorWindow interfaces, and visual scene-hierarchy indicators. The editor tools allow developers to non-destructively preview optimization operations before committing changes to the target scene asset.

Custom Scene Inspector Tools

• Optimizer Manager Hub: A centralized inspector panel attached to top-level scene managers, presenting granular control over material merging, texture atlas generation, and component stripping.
• Hierarchical Mesh Grouping: Automatically segregates target objects by spatial bounds, lightmap indices, and material IDs to generate localized mesh clusters.
• Interactive Material Re-mapper: Detects duplicate property bindings across disparate materials and automatically collapses identical parameters into unified material slots.
• UI & Graphic Batching Profiler: Analyzes Canvas hierarchies to isolate draw-call breakers such as alternating texture sources, mixed Z-depth values, and redundant raycast targets.

Data Preservation & Non-Destructive Workflows

To avoid corrupting source scene structures, processed geometry and baked texture atlases are outputted into designated generated-asset folders. A state restoration matrix tracks original object transform offsets, script attachments, and component properties, enabling single-click rollback capabilities directly within the custom inspector.

Quick-Start Unity Integration Guide

Implementing Super Level Optimizer 2 into an active development project requires configuring manager references, establishing layer masks, and running execution passes via editor automation or script calls.

Setup Steps

Follow these steps to initialize and run an optimization pipeline within your target scene:

using UnityEngine;
using SuperLevelOptimizer;

public class LevelOptimizationRunner : MonoBehaviour
{
    [SerializeField] private OptimizationProfile profile;
    [SerializeField] private GameObject levelRoot;

    [ContextMenu("Execute Optimization")]
    public void RunOptimizationPass()
    {
        if (profile == null || levelRoot == null)
        {
            Debug.LogError("[Optimizer] Profile or Level Root missing from configuration.");
            return;
        }

        LevelOptimizerEngine optimizer = new LevelOptimizerEngine(profile);
        OptimizationResult result = optimizer.BakeTargetHierarchy(levelRoot);

        Debug.Log($"[Optimizer] Success: Processed target hierarchy under {levelRoot.name}.");
    }
}

• Add a LevelOptimizerEngine component to your target scene root or setup an Editor-only orchestrator script.
• Assign an active OptimizationProfile asset containing your preferred texture atlas sizes and geometry combination flags.
• Mark interactive or moving dynamic objects with exclusion tags or separate physics layers to avoid static mesh merging.
• Trigger the optimization pass directly through the inspector window prior to building your project executable.

Performance Profiling & Memory Metrics

The primary performance objective when deploying Super Level Optimizer 2 is minimizing draw call count (SetPass Calls) and reducing CPU frame time dedicated to transform evaluation and batch preparation.

Rendering & Memory Optimization Summary

By merging static geometries that share textures into single combined meshes using unified texture atlases, scene batch counts drop significantly. Below is a comparative breakdown of runtime characteristics before and after executing the optimization pipeline:

• Draw Call Reduction: Consolidates disparate mesh renderers into unified vertex streams, lowering total SetPass calls on hardware targets.
• Memory Footprint vs. Bandwidth: While creating consolidated texture atlases increases active VRAM usage based on texture resolutions, it decreases total GPU state changes and bus transfers.
• Garbage Collection Overhead: The asset utilizes pre-allocated C# arrays and structural buffers during runtime operations, preventing GC allocations during frame execution.
• IL2CPP Build Efficiency: Built with IL2CPP code generation in mind, using strongly-typed data structures and native array memory copying routines to ensure clean target execution.

Developers Who Downloaded This Also Downloaded

Related Unity Tools Assets