FactorableBehaviour

Abstract MonoBehaviour base class for scene objects managed by a ScriptableFactory. Implements IFactorable with full GameObject lifecycle management — deactivation on instantiate, re-parenting on spawn/despawn, and automatic scene transfer. Subclass this for any pooled object that needs a Transform, components, and scene presence.

Definition

Namespace: Paragon.Core.ScriptableFactory Assembly: Paragon.dll

public abstract class FactorableBehaviour : ParagonBehaviour, IFactorable

Inherits: ParagonBehaviour → SerializedMonoBehaviour Implements: IFactorable

Generic Variant

public abstract class FactorableBehaviour<TData> : FactorableBehaviour, IFactorable<TData>
    where TData : FactorableData

Implements additionally: IFactorable<TData>

Remarks

FactorableBehaviour uses explicit interface implementation for IFactorable methods, meaning the lifecycle hooks (OnInstantiate, OnSpawn, OnDespawn, OnDestroy) are only callable through the IFactorable interface (i.e., by the factory). Subclasses override the protected virtual counterparts instead.

GameObject Management

Phase	gameObject.activeSelf	transform.parent	Scene
After Instantiate	false	Factory transform	Factory's scene
After Spawn	true	null (root)	Active scene (via MoveToActiveScene())
After Despawn	false	Factory transform	Factory's scene

The onDestroy flag prevents re-parenting during Unity's OnDestroy() callback (when the factory itself may be destroyed).

Quick Lookup

Goal	How
Create a pooled scene object	Subclass FactorableBehaviour, override OnSpawn()
Add data initialization	Subclass FactorableBehaviour<TData>, override InitializeData(TData)
Return to pool from self	Call Despawn()
Permanently destroy	Call Destroy()
Check if active	Read IsSpawned
Setup on first creation	Override OnInstantiate()
Cleanup on despawn	Override OnDespawn()

Properties

IsSpawned

Returns true while the object is spawned and active.

public bool IsSpawned { get; }

Methods

Despawn

Returns this object to its owning factory's pool. No-op if the object has no factory reference.

public void Despawn()

Destroy

Permanently destroys the underlying GameObject.

public void Destroy()

Extension Points

Optional Overrides

Method	Called When	Purpose
OnInstantiate()	Factory creates instance (once)	One-time setup, cache component references
OnSpawn()	Object activated from pool	Initialize per-spawn state, enable systems
OnDespawn()	Object returned to pool	Reset state, disable systems, release references
OnDestroy()	Unity's OnDestroy callback	Final cleanup (auto-despawns if still spawned)

Required Overrides (Generic Variant)

Method	Purpose
InitializeData(TData data)	Configure object from data record (abstract in FactorableBehaviour<TData>)

Implementation Requirements

When subclassing FactorableBehaviour, you MUST:

1. Mark the class as a MonoBehaviour component (inheriting from FactorableBehaviour handles this)

2. Keep the class concrete (non-abstract) if it will be used as a prefab component

When subclassing FactorableBehaviour<TData>, you MUST additionally:

1. Override InitializeData(TData data) (abstract)

2. Apply data configuration before the object is used (called by factory before spawn)

You SHOULD:

• Cache component references in OnInstantiate() (runs once per instance, not per spawn)

• Reset all per-spawn state in OnDespawn() to ensure clean re-use from pool

• Avoid calling base.OnDestroy() unless you understand the auto-despawn behavior

You SHOULD NOT:

• Call IFactorable.OnSpawn() or IFactorable.OnDespawn() directly — these are for the factory

• Assume OnDestroy() runs before OnDespawn() — the base class auto-despawns first

• Instantiate FactorableBehaviour objects with Object.Instantiate() — always use the factory

Common Pitfalls

Double-spawn assertion OnSpawn() asserts if IsSpawned is already true. This fires if the factory tries to spawn an object that was not properly despawned. Ensure every spawn has a matching despawn.

Double-despawn assertion OnDespawn() asserts if IsSpawned is false. This fires if Despawn() is called twice or on an object that was never spawned.

Manual instantiation bypasses lifecycle Objects created via Object.Instantiate() instead of the factory will have no factory reference. Despawn() becomes a no-op, and the object will not be pooled.

OnDestroy during application quit Unity calls OnDestroy() during application quit in undefined order. The onDestroy flag prevents re-parenting to a potentially-destroyed factory, but additional cleanup in your OnDestroy() override should guard against missing references.

Examples

Basic Pooled Object

using Paragon.Core.ScriptableFactory;
using UnityEngine;

public class Projectile : FactorableBehaviour
{
    private Rigidbody rb;
    private TrailRenderer trail;

    protected override void OnInstantiate()
    {
        // Cache once — persists across spawn/despawn cycles
        rb = GetComponent<Rigidbody>();
        trail = GetComponent<TrailRenderer>();
    }

    protected override void OnSpawn()
    {
        trail.Clear();
        rb.linearVelocity = transform.forward * 20f;
    }

    protected override void OnDespawn()
    {
        rb.linearVelocity = Vector3.zero;
        rb.angularVelocity = Vector3.zero;
    }

    private void OnCollisionEnter(Collision collision)
    {
        // Return to pool on impact
        Despawn();
    }
}

Data-Driven Object

using System;
using Paragon.Core.ScriptableFactory;
using UnityEngine;

[Serializable]
public record EnemyData : FactorableData
{
    public float maxHealth = 100f;
    public float moveSpeed = 3f;
    public Color tintColor = Color.white;
}

public class Enemy : FactorableBehaviour<EnemyData>
{
    private float currentHealth;
    private float moveSpeed;
    private Renderer meshRenderer;

    protected override void OnInstantiate()
    {
        meshRenderer = GetComponentInChildren<Renderer>();
    }

    protected override void InitializeData(EnemyData data)
    {
        currentHealth = data.maxHealth;
        moveSpeed = data.moveSpeed;
        meshRenderer.material.color = data.tintColor;
    }

    protected override void OnSpawn()
    {
        // Ready to move and fight
    }

    protected override void OnDespawn()
    {
        currentHealth = 0;
    }
}

See Also

• IFactorable — interface this class implements

• FactorableObject — plain C# alternative (no GameObject)

• FactorableScriptableObject — ScriptableObject alternative

• Factorable Object — subsystem overview

• FactorableData — data records for the generic variant