YooAsset's Unity Asset Packaging Strategies: From Directory Packs to Shared Bundles

Core Technology - Resource Packaging Strategy

Chapter: 07 - Core Technology - Resource Packaging System Reading time: about 30 minutes Prerequisite: understanding of YooAsset basic concepts

I. Introduction

This chapter deeply analyzes YooAsset resource packaging strategies. Resource packaging is the core link of YooAsset resource management. A reasonable packaging strategy can significantly improve game performance, reduce package size, and speed up loading. Deeply understanding packaging strategies is key to using YooAsset well.

YooAsset provides flexible packaging rules and multiple packaging strategies. This chapter will analyze the principles, applicable scenarios, and best practices of these strategies in detail.

II. Packaging Basics

2.1 Bundle Size Control

Bundle size is an important factor in packaging strategy:

Bundle too large:

A single Bundle over 50MB leads to long download times
Takes up a lot of memory when loading
Long loading time, affects user experience

Bundle too small:

Too many Bundles, increases management complexity
Frequent I/O operations affect performance
Complex dependency relationships

Recommended Bundle sizes:

Mobile: 1-10MB
PC: 5-50MB
WebGL: 1-5MB
No single Bundle over 50MB

2.2 Resource Classification

Reasonable resource classification is the foundation of packaging strategy:

By type:

UI resources: interface Prefabs, images, fonts
Character resources: models, animations, textures
Scene resources: scene files, lights
Audio resources: background music, sound effects
Data resources: JSON, XML, ScriptableObject

By usage frequency:

Startup-required: login, main scene
Commonly used: UI, characters
Occasionally used: storylines, animations
Rarely used: hidden content

By update frequency:

Stable resources: basically unchanged resources
Frequently updated: event and holiday content
Rarely updated: core gameplay

III. Packaging Strategies

3.1 Basic Packaging Strategies

Pack by directory:

Package all resources in the same directory into one Bundle.

// Pack entire UI directory
var uiCollector = new AssetBundleCollector
{
    CollectPath = "Assets/UI",
    PackRuleType = ECollectorPackRuleType.Directory,
};

Advantages:

Simple and intuitive
Easy to manage

Disadvantages:

Can lead to Bundles too large or too small

Applicable scenarios:

Resources with clear module boundaries

Pack by Prefab:

Each Prefab is packed into a separate Bundle.

// Each UI Prefab packed separately
var prefabCollector = new AssetBundleCollector
{
    CollectPath = "Assets/UI/Prefabs",
    PackRuleType = ECollectorPackRuleType.Prefab,
};

Advantages:

Bundle size controllable
Clear dependency relationships

Disadvantages:

Shared resources get packed multiple times

Applicable scenarios:

Independent functional modules

3.2 Advanced Packaging Strategies

Dependency sharing packaging:

Extract resources shared by multiple modules into a shared Bundle.

// Shared resources
var sharedCollector = new AssetBundleCollector
{
    CollectPath = "Assets/Shared",
    PackRuleType = ECollectorPackRuleType.Directory,
};

// Business module
var moduleACollector = new AssetBundleCollector
{
    CollectPath = "Assets/ModuleA",
    PackRuleType = ECollectorPackRuleType.Directory,
    SharedPackRule = true, // share dependency resources
};

Advantages:

Reduce redundancy
Reduce package size

Disadvantages:

Complex dependency relationships

Applicable scenarios:

Resources shared by multiple modules

Layered packaging:

Pack resources by importance into layers.

// Core layer: required at startup
var coreCollector = new AssetBundleCollector
{
    CollectPath = "Assets/Core",
    PackRuleType = ECollectorPackRuleType.Directory,
    BundlePriority = 100, // highest priority
};

// Business layer: commonly used
var businessCollector = new AssetBundleCollector
{
    CollectPath = "Assets/Business",
    PackRuleType = ECollectorPackRuleType.Directory,
    BundlePriority = 50,
};

// Content layer: occasionally used
var contentCollector = new AssetBundleCollector
{
    CollectPath = "Assets/Content",
    PackRuleType = ECollectorPackRuleType.Directory,
    BundlePriority = 10,
};

Advantages:

Supports fine-grained loading
Optimizes startup performance

Disadvantages:

Complex configuration

Applicable scenarios:

Large games

3.3 Dynamic Packaging Strategies

Pack by tag:

Use tags to flexibly control resource assignment.

// Categorize by tag
var taggedAssets = assets
    .Where(a => a.HasTag("critical"))
    .ToList();

Advantages:

Flexible
Does not depend on directory structure

Disadvantages:

Requires additional maintenance of tags

Pack by version:

Different versions pack different Bundles.

if (isStableVersion)
{
    // stable version packaging
}
else
{
    // test version packaging
}

Applicable scenarios:

A/B testing
Multi-version management

IV. Dependency Management

4.1 Dependency Analysis

Dependency analysis is key to packaging strategy:

Dependency analysis tools:

AssetBundle Browser: built into Unity
YooAsset Asset Scanner: built-in scanning tool
Addressables Analyze: Addressables tool

Dependency relationships:

Direct dependency: A references B
Indirect dependency: A references C, C references B
Circular dependency: A → B → A (should be avoided)

4.2 Shared Resource Handling

Shared resources are key to dependency management:

Shared Bundle:

// Extract shared resources into an independent Bundle
var sharedBundle = ExtractSharedResources(assets);

Shared resource identification:

Resources referenced by multiple Bundles should be extracted into a shared Bundle.

Shared Bundle advantages:

Reduce redundant packaging
Reduce package size
Speed up loading

4.3 Dependency Graph Optimization

// Optimize dependency graph
public class DependencyOptimizer
{
    public void OptimizeDependencies(BuildMap buildMap)
    {
        // 1. Detect circular dependencies
        DetectCycles(buildMap);
        
        // 2. Extract shared resources
        ExtractSharedAssets(buildMap);
        
        // 3. Optimize Bundle size
        OptimizeBundleSize(buildMap);
    }
}

Circular dependency detection:

Use graph algorithms to detect circular dependencies.

Shared resource extraction:

Extract shared resources into independent Bundles.

Bundle size optimization:

Optimize Bundle size by splitting or merging.

V. Sub-packaging Strategies

5.1 Installer Sub-packaging

Divide resources into built-in resources and updatable resources:

Built-in resources:

Required at startup
Core gameplay
No hot update needed

Updatable resources:

Content updates
Bug fixes
Event content

Implementation:

// Built-in resource Collector
var buildinCollector = new AssetBundleCollector
{
    CollectPath = "Assets/Core",
    PackRuleType = ECollectorPackRuleType.Directory,
    BuildInBuildPipeline = true, // pack into installer
};

// Updatable resource Collector
var updatableCollector = new AssetBundleCollector
{
    CollectPath = "Assets/Content",
    PackRuleType = ECollectorPackRuleType.Directory,
    BuildInBuildPipeline = false, // do not pack into installer
};

5.2 Channel Sub-packaging

Different channels have different package contents:

Channel differences:

App store requirements
Platform limitations
Laws and regulations

Implementation:

// Configure based on channel
public class ChannelConfig
{
    public string ChannelName;
    public List<string> Bundles;
}

5.3 Platform Sub-packaging

Different platforms have different resources:

Platform differences:

Texture compression formats (DXT, ETC, PVRTC, ASTC)
Shader precision
Fonts and localization

Implementation:

YooAsset automatically builds by target platform, no manual configuration needed.

VI. Best Practices

6.1 Startup Performance Optimization

Startup-required resources:

Pack startup-required resources into the installer.

Load on demand:

Load non-startup-required resources on demand.

Preloading:

Preload resources needed in the future during game idle time.

6.2 Memory Optimization

Bundle size control:

Avoid single Bundles being too large.

Resource reuse:

Reduce memory usage through shared Bundles.

Timely release:

Release unused resources promptly.

6.3 Package Size Optimization

Compression strategy:

Choose appropriate compression methods based on resource type.

Redundancy elimination:

Eliminate redundancy through shared Bundles.

On-demand inclusion:

Only include necessary resources.

6.4 Loading Performance Optimization

Preloading:

Preload commonly used resources at game startup.

Frame-distributed loading:

Spread resource loading across multiple frames.

Priority management:

Load critical resources first.

VII. Summary

This chapter deeply analyzes YooAsset resource packaging strategies, including:

Packaging basics: Bundle size control, resource classification
Packaging strategies: basic (by directory, by Prefab), advanced (dependency sharing, layering), dynamic (by tag, by version)
Dependency management: dependency analysis, shared resource handling, dependency graph optimization
Sub-packaging strategies: installer sub-packaging, channel sub-packaging, platform sub-packaging
Best practices: startup performance, memory, package size, loading performance

With a reasonable packaging strategy, you can significantly improve game performance, reduce package size, and speed up loading.

Next: Core Technology - Compression and Encryption