Game.Rendering.MeshLoadingState

Assembly:
Assembly-CSharp (main game assembly)

Namespace:
Game.Rendering

Type:
enum

Base:
System.Enum (backed by System.Int32)

Summary:
Represents the lifecycle states used by the mesh loading pipeline in the renderer. Each value indicates the current stage of loading, uploading, or releasing a mesh resource (CPU/GPU). Useful for tracking progress, making decisions about resource transitions, and debugging loading-related issues in mods or renderer code. Typical transitions move from None → Pending → Loading → Copying → Complete, with Obsolete/Unloading used for resources that are being replaced or freed. Default is provided as a fallback state.

---

Fields

• None
  The default/uninitialized state (typically value 0). No loading activity is ongoing.

• Pending
  The mesh is queued for loading (waiting to start actual I/O or processing).

• Loading
  Active loading is occurring (reading/decoding mesh data, CPU-side processing).

• Copying
  Data is being copied/uploaded to the GPU or otherwise transferred to its final location.

• Complete
  The mesh has finished loading and is ready for use by the renderer.

• Obsolete
  The mesh data has been superseded or invalidated (e.g., newer version exists). Usually a precursor to unloading.

• Unloading
  The mesh is in the process of being released/freed.

• Default
  A fallback state; can be used as an explicit default marker distinct from None.

Properties

• (None)
  This enum does not define properties. Use standard enum operations (casting, comparisons, Enum.Parse, etc.).

Constructors

• (None)
  Enums do not have user-defined constructors. The default numeric value corresponds to the first declared member (None).

Methods

• (None defined)
  No custom methods are declared on this enum. Inherited System.Enum/Object methods are available (ToString, CompareTo, HasFlag, etc.).

Usage Example

// Typical usage: tracking and reacting to mesh loading state
MeshLoadingState state = MeshLoadingState.None;

// Queue for loading
state = MeshLoadingState.Pending;

// Later, when processing starts:
state = MeshLoadingState.Loading;

// After uploading to GPU:
state = MeshLoadingState.Copying;

// When ready:
state = MeshLoadingState.Complete;

// Check state before rendering or binding:
if (state == MeshLoadingState.Complete)
{
    // use the mesh
}

// Switch-based handling:
switch (state)
{
    case MeshLoadingState.Pending:
    case MeshLoadingState.Loading:
    case MeshLoadingState.Copying:
        // show loading placeholder
        break;
    case MeshLoadingState.Complete:
        // render normally
        break;
    case MeshLoadingState.Obsolete:
    case MeshLoadingState.Unloading:
        // free or ignore resource
        break;
    default:
        // fallback behavior
        break;
}