Object

The Object subsystem defines the factorable object contract — the types that a ScriptableFactory can instantiate, pool, spawn, and despawn. It provides three abstract base classes, one for each Unity object paradigm, plus the IFactorable interface they all implement.

Architecture

Choosing a Base Class

Base Class	Unity Type	Use When
FactorableBehaviour	MonoBehaviour	Object needs a GameObject with transforms, components, and scene presence
FactorableObject	Plain C# object	Object is pure data/logic with no Unity scene representation
FactorableScriptableObject	ScriptableObject	Object is an asset-like instance that lives outside the scene hierarchy

All three follow the same lifecycle and provide identical virtual method hooks. The only differences are in how Unity manages the underlying object (GameObject vs C# instance vs ScriptableObject).

Object Lifecycle

Lifecycle Details

Phase	What Happens	IsSpawned	FactorableBehaviour Specifics
Instantiate	Factory creates instance, calls OnInstantiate()	false	GameObject deactivated, parented to factory
Spawn	Factory activates instance, calls OnSpawn()	true	GameObject activated, unparented, moved to active scene
Despawn	Factory deactivates instance, calls OnDespawn()	false	GameObject deactivated, re-parented to factory
Destroy	Instance removed from pool	false	Object.Destroy(gameObject) called

Data-Driven Variants

Each base class has a generic variant (e.g., FactorableBehaviour<TData>) that adds data initialization via IFactorable<TData>:

// 1. Define your data record
[Serializable]
public record EnemyData : FactorableData
{
    public float health = 100f;
    public float speed = 3f;
}

// 2. Subclass with data binding
public class Enemy : FactorableBehaviour<EnemyData>
{
    private float currentHealth;

    protected override void InitializeData(EnemyData data)
    {
        currentHealth = data.health;
        // Configure from data before spawn
    }

    protected override void OnSpawn()
    {
        // Object is now active in the scene
    }
}

Quick Start

Creating a Factorable MonoBehaviour

using Paragon.Core.ScriptableFactory;

public class Projectile : FactorableBehaviour
{
    protected override void OnSpawn()
    {
        // Initialize projectile on spawn
    }

    protected override void OnDespawn()
    {
        // Reset state when returned to pool
    }
}

Despawning an Object (Self-Return to Pool)

// From within the factorable object:
Despawn();

// Or from external code via the factory:
factory.Despawn(myObject);

Classes

Class	Description
IFactorable	Interface defining the factorable object contract
FactorableBehaviour	Abstract MonoBehaviour base for scene objects
FactorableObject	Abstract C# object base for non-Unity instances
FactorableScriptableObject	Abstract ScriptableObject base for asset-like instances

See Also

• Scriptable Factory — parent system overview

• FactorableData — data records used with IFactorable<TData>