载入中...
搜索中...
未找到
类列表
这里列出了所有类、结构、联合以及接口定义等，并附带简要说明:
[详情级别 123456]
| ►Ndtl | |
| ►Nutility | |
| CDrawJagged | |
| CDrawJaggedRandom | |
| CDrawJagged | |
| CDrawJaggedRandom | |
| ►Nediting | |
| ►NTaskService | |
| CTaskRecord | |
| ►Neve | Build metadata (engine git commit, build time, third-party version) |
| ►Naction | |
| ►Ngame_event_adapter | |
| CActionGameEventSink | Explicit bridge from gameplay:event blocks to one persistent GameEventLog |
| ►Ninput | |
| CActionCancelMatch | Owning cancel match between an input/ability tag and an active window |
| CActionCancelWindowState | Authoritative projection of active cancel windows |
| CActionComboMatch | Owning deterministic match between one semantic input and an active combo window |
| CActionComboWindowState | Authoritative projection of active semantic combo-input windows |
| CActionInputBuffer | Owner-thread FIFO/priority buffer of semantic combat inputs |
| CBufferedInput | One buffered semantic command tagged with the tick it was pressed |
| CAbilityActivation | Owning link between an ability activation and its action execution |
| CAbilityControllerRuntime | Shared controller that routes player or AI intents into AbilityRuntime |
| CAbilityDefinition | Canonical immutable-by-convention definition of a grantable ability |
| CAbilityGrantState | Owning snapshot of one granted ability's mutable state |
| CAbilityIntent | Owning request to activate one granted ability |
| CAbilityRuntime | Owner-thread coordinator for grant and activation state |
| CAbilityTrigger | One gameplay-event trigger declared by an ability definition |
| CAction | Factory module for script-owned action/ability protocol runtimes |
| CActionActiveBlock | Owning per-step sample of one currently active timeline state |
| CActionAdvance | Result payload for one deterministic advance call |
| CActionAnimationSection | Objective animation segment placed on the montage presentation lane |
| CActionAttackVfxBinding | Owning validated AttackVfx settings shared by runtime and editor preview |
| CActionAttackVfxCue | One cue scheduled relative to AttackVfx play() |
| CActionAudioBinding | Owning validated settings shared by Audio runtime and editor preview |
| CActionAudioWaveform | Owning waveform projection returned by an optional audio provider |
| CActionAudioWaveformBucket | One normalized min/max envelope bucket in timeline display order |
| CActionAudioWaveformRequest | Owning request for a bounded audio-block waveform projection |
| CActionBlockRuntime | Owner-thread lifecycle router for timeline notifies and active blocks |
| CActionCameraCueBinding | Owning validated camera impulse shared by action runtime and camera targets |
| CActionDamageBinding | Owning validated damage request authored on an action timeline |
| CActionDamageImpulse | Renderer- and combat-implementation-neutral knockback impulse |
| CActionDefinition | Immutable-by-convention definition of one action kind |
| CActionExecution | Read-only view of one execution owned by ActionRuntime |
| CActionExecutionIdTag | Opaque runtime identity for one ActionExecution |
| CActionGameplayEventBinding | Owning validated event request authored on an action timeline |
| CActionMontageSettings | Montage-wide presentation settings persisted with the action timeline |
| CActionNotify | Instantaneous typed event placed on an action track |
| CActionNotifyContext | Context linking a routed event to its action execution |
| CActionNotifyDescriptor | Owning editor/runtime contract for one notify type |
| CActionNotifyRegistry | Canonical notify descriptor owner and runtime handler router |
| CActionNotifyState | Typed interval with explicit enter/exit boundaries |
| CActionParameterCurveBinding | Validated owning continuous parameter binding |
| CActionParameterKey | One normalized, owning parameter-curve key |
| CActionParameterSample | Owning continuous parameter sample emitted by ActionBlockRuntime |
| CActionPrefabSpawnBinding | Fully validated, owning settings for one prefab-spawn state block |
| CActionPreviewCue | Owning presentation cue derived from a canonical timeline event |
| CActionPreviewFrame | Complete frame atomically prepared and then presented by a preview host |
| CActionPreviewPoint3 | One owning 3D point in an animation root-motion trajectory |
| CActionRequest | One caller-owned request to instantiate an action execution |
| CActionRuntime | Deterministic action lifecycle coordinator |
| CActionServices | Borrowed composition ports used by one ActionRuntime owner |
| CActionSpatialBinding | Validated spatial settings decoded from a notify payload |
| CActionSpatialVector3 | Owning three-component value used at the action/presentation boundary |
| CActionStateWindowBinding | Owning validated state-window request authored on an action timeline |
| CActionTimeline | Canonical action timeline asset shared by runtime and editor |
| CActionTimelineEvent | Owning event projection returned by the runtime sampler |
| CActionTiming | Deterministic simulation durations for the three timed action phases |
| CActionTrack | Ordered semantic lane in one action timeline |
| CActionTransition | One phase change observed while advancing an action |
| CActionVfxBinding | Owning validated VFX settings shared by runtime and editor preview |
| CIAbilityIntentSource | Pull boundary shared by player input queues and AI decision adapters |
| CIActionAudioWaveformProvider | Optional synchronous audio waveform service consumed by the action editor |
| CIActionCameraCueSink | Optional open target for instantaneous action camera cues |
| CIActionConditionEvaluator | Read-only condition composition port |
| CIActionDamageSink | Optional target-domain adapter for timeline damage |
| CIActionEffectExecutor | Active-phase effect/operation preparation port |
| CIActionEffectOperation | Move-only staged Active operation |
| CIActionGameplayEventSink | Optional target-domain adapter for instantaneous timeline gameplay events |
| CIActionNotifyHandler | Consumer-owned handler for one registered notify type |
| CIActionNotifyProvider | Optional module provider that installs handlers into a new registry |
| CIActionParameterSink | Optional open target for continuous action parameters |
| CIActionPrefabInstances | Optional owner-thread service for prefab instances detached from an action block |
| CIActionPreviewSink | Host boundary for 3D animation, VFX, audio and camera preview |
| CIActionPreviewSinkProvider | Optional owner-thread provider of one independently owned action preview layer |
| CIActionResourceProvider | Resource-account lookup port for canonical CostSpec operations |
| CIActionRootMotionSource | Optional animation provider that samples an owning root-motion polyline |
| CIActionStateWindowSink | Optional target-domain adapter for paired action state windows |
| CIActionTargetResolver | Targeting composition port |
| CIActionVfxDurationProvider | Optional synchronous provider of authored VFX resource duration |
| CPlayerAbilityIntentQueue | Owner-thread FIFO adapter for player input and command bindings |
| CPrefabInstanceHandleTag | Owner tag preventing prefab instance handles from mixing with other registries |
| CPrefabInstanceInfo | Owning inspection record for one externally managed prefab instance |
| CSensingTargetingAdapter | Reusable adapter from the sensing TargetingResolver to ActionRuntime |
| ►Naction_editor | |
| ►CActionEditorModule | Composition adapter that contributes action-timeline commands, automation targets, and the script-owned ActionTimelineEditor factory |
| CTargetFactory | |
| ►Nagent | |
| ►Ndetail | |
| CPolicyGraph | PolicyGraph public API |
| CRandom | Random public API |
| CAgent | Squirrel entry eve.Agent(): owner-thread synchronous training, inference and replay |
| ►CAgentTensor | Manager-owned optional tensor backend. Owner thread only; revokes before destruction |
| CImpl | |
| CConfig | Bounded search configuration; seed streams for environment, search and learning are separate |
| CIEnvironment | Adapter for a resettable game, simulation, UI or other decision-making environment. @ownership The caller owns the environment and all domain state. The runner borrows it only for the synchronous call; no references escape. @thread Call on the domain owner thread. Callbacks may call unrelated services, but must not reenter or destroy this environment. The runner holds no locks |
| CIGpuPolicyBackend | Optional GPU policy service, registered independently of eager tensor CPU. @ownership Same synchronous borrowing contract as IPolicyBackend; revoke before destruction. @thread Device owner thread only. No callbacks, reentry or device teardown during a call |
| CIPolicyBackend | Optional inference service. Providers own their registration and revoke before destruction. @thread Owner thread only; no reentry, provider unload or external callbacks during inference. @ownership Inputs are borrowed only for the call. Outputs own all data. Core resolves the capability anew for each inference; it never retains a provider across environment callbacks |
| CObservation | Owning state projection; action IDs index a fixed domain action catalogue |
| CPolicy | Owning version-1 portable network weights; import validates the entire value before use |
| CReport | Owning search result; reward, coverage and failures remain separate evidence |
| CTrace | In-memory versioned replay evidence, independent of learned model state |
| CTraceStep | Owning executed action and resulting observation; no domain pointers are retained |
| ►Nanimation | |
| ►Ndetail | |
| CMotionSchemaState | MotionSchemaState public API |
| CPoseInertia | PoseInertia public API |
| ►Nhair | Convenience helpers for hair/tail/accessory spring chains on DynamicBoneSolver |
| CChainDesc | One named spring chain with game-friendly hair defaults |
| CAnimation | Animation module — tween factory + 2D sprite-sheet / Spine + 3D skeletal playback (player / state machine / motion matching) + control-theory procedural drivers + motion trails + per-frame pump. Script: anim <- eve.Animation(); |
| ►CAnimationTensor | Manager-owned MeshRet neural retarget satellite (animation + tensor). @thread Owner/composition thread only; revokes capability before destruction |
| CImpl | |
| CAnimationTrackInput | One synchronous borrowed batch input; destination and bytes must outlive the call |
| CAnimBatch | Parallel batch evaluator for independent character clip poses. Script type: AnimBatch |
| CAnimBoneMask | Per-bone weights used by override and additive animation layers |
| CAnimClip | Keyframed skeletal animation clip (local TRS tracks per bone). Script type: AnimClip |
| CAnimClipBinaryAccess | |
| ►CAnimClipRegistry | Weak path→clip registry for animation hot reload |
| CReloadEvent | Owning event value emitted after an EVA path reload attempt |
| CAnimConstraintStack | Ordered main-thread post-process stack with aim, limb IK and foot planting |
| ►CAnimCurveLibrary | Owned scalar animation curves indexed by stable source and channel names |
| CImpl | |
| CAnimGraph | Composable runtime pose graph supporting clips, blends, additive layers, per-bone masks, one-shots and 1D/2D blend spaces. Script type: AnimGraph |
| CAnimImporter | Animation import helpers |
| ►CAnimInertializer | Finite-duration pose transition relative to a continuously sampled target |
| CImpl | |
| CAnimLattice | CPU 3D lattice scale-deformer (晶格缩放变形) |
| CAnimLayerMixer | Combines a borrowed base pose source with ordered override/additive layers |
| CAnimPlayer | Single-clip (or cross-fading) 3D animation player. Script type: AnimPlayer |
| CAnimPose | Evaluated local (and optional world) pose for an AnimSkeleton. Script type: AnimPose |
| CAnimRetargetProfile | Settings and diagnostics for offline skeletal animation retargeting |
| CAnimSkeleton | 3D bone hierarchy + bind-pose local TRS for skeletal animation. Independent of ik::Skeleton3D (FABRIK). Script type: AnimSkeleton |
| CAnimSkin | CPU linear-blend skinning binding for one mesh against an AnimSkeleton |
| CAnimSkinStreamData | Owned native streams for constructing a skin outside the model importer |
| CAnimSmrIkChain | Two-bone IK chain used to realize an interaction correction |
| CAnimSmrSensor | One semantically consistent sensor attached to a bone (classical SCS stand-in) |
| CAnimSmrSensorCloud | Bone-attached sensor cloud for skinned-motion-retarget interaction queries. Script type: AnimSmrSensorCloud |
| CAnimStateMachine | Clip-driven animation state machine with float/bool/trigger parameters and cross-fade transitions. Script type: AnimStateMachine |
| CAnimSyncGroup | Marker-aware synchronization group for locomotion animation players |
| CAnimTrail | Motion trail / afterimage recorder + 2D trajectory drawer |
| CColorPointerSink | Sink that writes into borrowed RGBA float pointers. @ownership Does not own the pointers; caller must keep them alive while bound |
| CControlAnim | Control-theory procedural animation for named scalar properties |
| CControlPose | Control-theory procedural pose driver: tracks a target AnimPose with per-channel second-order / spring / PD dynamics (same laws as ControlAnim). Script type: ControlPose |
| CDampedSpringStep | Closed-form coefficients for one damped-spring time step (Juckett) |
| CDynamicBoneChainConfig | Persisted name-based dynamic-bone chain configuration |
| CDynamicBoneColliderConfig | Persisted fixed or bone-following sphere/capsule configuration |
| CDynamicBoneConfig | Versioned, forward-compatible dynamic-bone asset definition |
| CDynamicBoneDebugCollider | One immutable model-space collider in a dynamic-bone debug snapshot |
| CDynamicBoneDebugParticle | One immutable model-space particle in a dynamic-bone debug snapshot |
| CDynamicBoneDebugSnapshot | Owning renderer-neutral snapshot safe after the solver changes |
| CDynamicBoneForceField | Read-only spatial force provider sampled by dynamic bone particles |
| CDynamicBoneParticleConfig | Persisted particle profile for one dynamic-bone chain particle |
| CDynamicBoneSolver | World-space spring-chain solver that writes results as local bone rotations |
| CDynamicBoneUpdateStats | Last-update counters for profiling and distance-culling verification |
| CFloatBufferSink | Sink that writes into buffer[index] (batch-friendly contiguous target). @ownership Does not own buffer; caller must keep the span alive while bound |
| CFloatPointerSink | Sink that writes into a borrowed float*. @ownership Does not own target; caller must keep it alive while bound |
| CFootIKConfig | Persisted paired-foot IK settings; runtime providers are intentionally excluded |
| CFootIKDebugFoot | Immutable model-space state for one foot in a tooling snapshot |
| CFootIKDebugSnapshot | Owning renderer-neutral paired-foot tooling snapshot |
| CFootIKGroundProvider | Physics-neutral downward ground-query provider for Foot IK |
| CFootIKLegConfig | Persisted name-based leg and optional toe mapping |
| CFootIKSolver | Paired-foot IK with contact smoothing and pelvis compensation |
| CIAnimPoseSource | Borrowed pose provider consumed by AnimLayerMixer |
| CIMontageClipProvider | Synchronous ownership-transfer port used to resolve montage clip URIs |
| CIMontageRootMotionReceiver | Optional receiver for filtered per-step root motion |
| CIMotionColorSink | Push target for a MotionColor motion |
| CIMotionFloatSink | Push target for a float motion. Lifetime is borrowed by MotionRuntime |
| CIMotionQuatSink | Push target for a MotionQuat motion |
| CIMotionVec2Sink | Push target for a MotionVec2 motion |
| CIMotionVec3Sink | Push target for a MotionVec3 motion |
| CISmrNeuralRetarget | Optional MeshRet/SMR neural retarget provider (implemented by animation_tensor) |
| CMat4 | Column-major 4x4 matrix (OpenGL / glTF / Assimp-compatible layout). Elements: m[col * 4 + row] |
| CMontageAdvance | Owning observation returned by one montage presentation step |
| CMontageClipAsset | Owning clip supplied while transactionally preparing a montage |
| CMontageCoordinator | Owns a fixed two-slot ping-pong topology for every animation layer |
| CMontageHandleTag | MontageHandleTag public API |
| CMontagePlayer | Presentation-only montage player over an ActionTimeline |
| CMontageRootMotionMask | Compatibility-only axis enable mask for montage root motion |
| CMotionBuilder | Configure then bind/run a float motion into a MotionRuntime |
| CMotionColor | Compact RGBA color used by motion adapters |
| CMotionColorBuilder | Color fluent builder (Tween / lerp only) |
| CMotionCostOverride | Copied clip-time interval overriding a matching cost, with inclusive start and exclusive end |
| ►CMotionDatabase | Baked motion-matching feature database from one or more AnimClips. Feature layout per frame: [0..1] root velocity xz [2..7] trajectory pos xz at +0.33/+0.66/+1.0s (character space) [8..9] trajectory facing dir xz at +1.0s [10..] selected joint world positions (xyz each) The optional locomotion layout has 19 trajectory and 11 pose dimensions; see setLocomotionFeatures(). Existing databases retain the basic layout. Script type: MotionDatabase |
| CFrame | Frame public API |
| CSchemaSampler | |
| CMotionFeatureChannel | Owning configuration for one ordered motion feature channel |
| CMotionFeatureCurveSample | Copied evaluated scalar curve query at a schema-relative time |
| CMotionFeatureLayout | Owning ordered feature layout; copied atomically by a database |
| CMotionFeatureTrajectorySample | Copied trajectory sample at an explicit offset from the current frame |
| CMotionHandle | Generation-checked slot identity for a live motion |
| CMotionLocomotionSample | Copied world displacement, velocity (metres/second), and yaw for a locomotion horizon |
| CMotionMatcher | Runtime motion matching player: builds a query feature from current pose + desired trajectory, searches MotionDatabase, inertializes into the moving best match. Script type: MotionMatcher |
| CMotionNormalizationRange | Copied clip-time interval contributing once to feature normalization; endpoints inclusive |
| CMotionQuat | Compact quaternion used by motion adapters (xyzw) |
| CMotionQuatBuilder | Quaternion fluent builder (Tween / slerp only) |
| ►CMotionRuntime | Owns typed motion slots and applies SimulationStep updates |
| CColorDesc | |
| CFloatDesc | FloatDesc public API |
| CQuatDesc | |
| CVec2Desc | |
| CVec3Desc | |
| CMotionSearchRange | Owning candidate interval in seconds in a database clip; endpoints inclusive |
| CMotionSequence | Schedule unspawned builders onto a shared MotionRuntime timeline |
| CMotionSequenceHandle | Playback handle for a sequence's child motions |
| CMotionTrajectorySample | Predicted world-space displacement and facing at a fixed future horizon |
| CMotionTransitionBlock | Copied clip-time interval forbidding new matches, with inclusive start and exclusive end |
| CMotionVec2 | Compact float2 used by motion adapters (avoids graphics math deps) |
| CMotionVec2Builder | Vec2 fluent builder |
| CMotionVec3 | Compact float3 used by motion adapters |
| CMotionVec3Builder | Vec3 fluent builder |
| ►COrientationWarping | Planar orientation warp applied after motion matching, never fed back into search |
| CImpl | |
| CPhysicalBalancePose | Authored-pose overlay that wobbles from world impulses and recovers balance |
| CQuatPointerSink | Sink that writes into borrowed quaternion xyzw float pointers. @ownership Does not own the pointers; caller must keep them alive while bound |
| CRootMotionPolicy | Policy applied after raw root-bone delta extraction. @ownership Value type; owned by AnimPlayer or the caller. @thread Owner thread only; no callbacks |
| CSecondOrderCoeffs | Control-theory helpers for procedural animation |
| CSmrFeatureBatch | Packed MeshRet-style features for one retarget inference window |
| CSmrMeshRetConfig | Hyperparameters for the builtin MeshRet-style graph |
| CSmrMeshRetNet | Builtin MeshRet-style PointNet + Transformer retarget (links eve::tensor). @thread Owner thread; not re-entrant |
| CSmrNeuralProvider | Capability provider selecting ONNX MeshRet or builtin tensor MeshRet. @ownership Owned by AnimationTensor; registered via cap::provide until revoke. @thread Owner/composition thread only; no callbacks while holding locks |
| CSmrNeuralRequest | Inputs for neural MeshRet-style skinned motion retarget |
| CSmrNeuralResult | Owning diagnostics from one neural retarget call |
| CSmrOnnxRunner | MeshRet-compatible ONNX runner on CPU via eve::tensor::OnnxModel |
| CSpineAnim | Spine animation player + 2D draw collector (region attachments) |
| CSpineAtlas | Esoteric Spine .atlas text parser (region rectangles + page metadata). Does not load image pixels — bind GPU textures by page name/index in SpineAnim. Script type: SpineAtlas |
| CSpineSkeleton | Runtime Spine skeleton pose (local + world bone transforms, slot attachments). Script type: SpineSkeleton |
| ►CSpineSkeletonData | Spine skeleton JSON data (bones / slots / skins / animations) |
| CAnimationData | |
| CAttachmentKey | |
| CBoneData | BoneData public API |
| CBoneTimeline | |
| CFloatKey | |
| CRegionAttachment | |
| CScaleKey | |
| CSkinData | |
| CSlotData | |
| CSlotTimeline | |
| CTranslateKey | |
| CSpriteAnim | 2D sprite-sheet clip player |
| CSpriteClip | Named 2D frame sequence referencing SpriteSheet frame indices. Script type: SpriteClip |
| CSpriteSheet | Sprite-sheet / texture-atlas frame table (pixel rects) |
| CTransformTRS | Local TRS used by skeletal animation (quaternion xyzw) |
| CTween | Property tween — interpolates named float properties from → to over time |
| CVec2PointerSink | Sink that writes into borrowed float x/y pointers. @ownership Does not own the pointers; caller must keep them alive while bound |
| CVec3PointerSink | Sink that writes into borrowed float x/y/z pointers. @ownership Does not own the pointers; caller must keep them alive while bound |
| ►Nanimation_editing | |
| CAnimationBoneTrack | Stable bone track addressed by skeleton bone name |
| CAnimationClipDocumentTarget | UI-neutral animation clip document with reversible stable-id timeline edits |
| CAnimationClipPreview | Immutable timeline scrub result tied to one document revision |
| CAnimationClipRuntimeBuilder | Optional bridge producing a real runtime AnimClip from an editor document |
| CAnimationEventRecord | Stable timeline event marker with optional payload |
| CAnimationGraphCompileResult | Compilation result for a stable-reference animation state graph asset |
| CAnimationMaskEntry | Per-bone blend mask entry in normalized [0, 1] weight space |
| CAnimationRetargetPreview | Non-destructive source-to-target skeleton mapping preview |
| CAnimationSampledBone | Sampled local transform returned by non-destructive timeline scrubbing |
| CAnimationSkeletonOverlayAdapter | Optional bridge extracting an overlay from a real animation pose |
| CAnimationStateGraphDomain | animation.state graph domain matching AnimStateMachine semantics |
| CAnimationStateGraphRuntimeBuilder | Optional bridge constructing the real animation runtime from a validated graph |
| CAnimationTransformKey | One stable transform key used by the animation timeline |
| CIAnimationClipEditTarget | Timeline editing capability for skeletal clips |
| CProceduralBoneOverlayBuilder | Builds renderer-neutral dynamic-bone and Foot IK debug primitives |
| CProceduralBoneOverlayOptions | Feature toggles and safety budget for procedural animation overlays |
| CSkeletonOverlayBone | Immutable renderer-neutral world-space bone snapshot |
| CSkeletonOverlayBuilder | Builds bone lines, joints, local axes and constraint arcs without a renderer dependency |
| CSkeletonOverlayOptions | Overlay density, feature toggles and hard safety budgets |
| ►Nanimation_editor | |
| CAnimationClipEditor | Timeline-style controller for one authored animation clip |
| ►CAnimationEditorModule | Composition adapter that contributes animation editing commands and automation targets |
| CTargetFactory | |
| ►Narchspace | |
| CArchSpace | Runtime ArchSpace module entry used for profile wiring and script discovery |
| CCatalogEntry | Built-in catalog entry resolved from an item catalogId |
| CCatalogPart | One parametric furniture part in catalog-local metres (Y-up) |
| CDocument | Authoritative architectural space document (Pascal-like node graph) |
| CMeshArrays | Interleaved GPU-upload arrays derived from MeshBake |
| CMeshBake | Renderer-neutral triangle mesh rebuilt from the document |
| CNode | One authored architectural node. Only fields for the active kind are meaningful |
| CVec2 | Metres on the level XZ plane |
| CVec3 | Metres in world/level space |
| ►Narchspace_editing | |
| CArchSpaceDocumentTarget | Revisioned ArchSpace document target for Inspector, tools and automation |
| ►Narchspace_editor | |
| ►CArchSpaceEditorModule | Composition adapter that contributes ArchSpace editing commands and automation targets |
| CTargetFactory | |
| ►Nartifact | |
| CBounds | Backend-neutral axis-aligned bounds copied from a generated part |
| CIGraphicsArtifactAdapter | Graphics resource publication capability, implemented by graphics |
| CIMapArtifactAdapter | Tile/map publication capability, implemented by the map module |
| CIPhysicsArtifactAdapter | Collider publication capability, implemented by physics |
| CISceneArtifactAdapter | Scene graph publication capability, implemented by the scene module |
| CPartView | Borrowed immutable view of one generated leaf |
| CPoint | Minimal point representation used at the publication boundary |
| CPreparedPublication | A prepared consumer mutation with a non-throwing visibility boundary |
| CProviderContract | Base contract for a consumer-owned artifact provider |
| CPublicationView | Borrowed immutable view of one complete generated publication |
| CPublishOptions | Required provider set for one artifact publication transaction |
| CPublishReceipt | Observable receipt from a successful provider transaction |
| ►Nasset | |
| ►Ndetail | |
| CTgaPixels | Owning top-down RGBA8 pixels decoded from a TGA source |
| CTiffPixels | Owning top-down RGB(A) TIFF pixels; unspecified fourth samples remain alpha data |
| CAssetCookProfile | Explicit deterministic target profile for one runtime variant |
| CAssetCookReceipt | Owning result of a completed and reopened deterministic Cook |
| CAtomicAssetPackageStore | Filesystem publisher whose failed prepare/verify leaves the destination unchanged |
| CAvailableAssetDependency | One externally supplied asset available to a Cook dependency closure |
| CCanonicalMeshAttribute | Owning float vertex attribute; one to four components per vertex |
| CCanonicalMeshData | Owning CPU mesh snapshot; UV arrays are packed ST pairs indexed by source set number. No pointers into the source archive are retained. Each array has one authoritative owner |
| CCanonicalMeshLimits | Allocation limits checked before decoding any vertex arrays. UV count is byte-budget bounded |
| CCookedCanonicalImage | Runtime definition and typed RGBA8 bulk generated from one canonical image source |
| CCookedCanonicalPcgGraph | Runtime metadata and deterministic PointGraph definition for one canonical PCG graph |
| CCookedCanonicalVolumeTexture | Runtime definition and RGBA8 bulk generated from one canonical volume |
| CDecodedEvpackImage | Owning validated RGBA8 mip chain independent of a graphics backend |
| CEvaArchive | Fully admitted source archive with its typed manifest and payloads |
| CEvaArchiveEntry | One owning regular-file entry inside an .eva archive |
| CEvaArchiveLimits | Admission budgets applied before allocating decoded archive entries |
| CEvaAssetChange | One canonical asset identity changed between source packages |
| CEvaAssetEntry | One typed asset definition in an .eva archive |
| CEvaDependency | One directed dependency between stable asset identities |
| CEvaDependencyValidation | Observable result of validating a package dependency closure |
| CEvaManifest | Validated, owning .eva manifest |
| CEvaPackageDiff | Deterministically ordered semantic package difference |
| CEvpack | Fully admitted owning runtime pack |
| CEvpackAssetHandle | Generation-scoped stable-reference resolution across mounted packages |
| CEvpackBuild | Complete input to deterministic .evpack assembly |
| CEvpackCapabilities | Actual runtime device capabilities used for variant selection |
| CEvpackChunk | Admitted immutable chunk metadata |
| CEvpackChunkHandle | Generation-scoped handle to one verified chunk in a mounted package |
| CEvpackChunkInput | Cooker-owned uncompressed chunk before deterministic package assembly |
| CEvpackHandle | Generation-scoped handle to one mounted runtime package |
| CEvpackImageDecodeLimits | Bounds applied before allocating decoded image bytes |
| CEvpackLimits | Resource limits checked before package allocations and hash work |
| CEvpackMountReceipt | Receipt returned after an atomic registry publication |
| CEvpackRangeMount | Admitted metadata plus an immutable range source retained by shared ownership |
| CEvpackRangeSource | Abstract immutable byte-range provider for files, mmap, HTTP or object storage |
| CEvpackRegistry | Thread-safe owner of current runtime package generations |
| CEvpackRegistryEvent | Immutable lifecycle event delivered to registry subscribers |
| CEvpackRegistrySubscription | Opaque identity used to cancel a registry subscription |
| CEvpackResourceReader | Immutable reader retaining an admitted pack by shared ownership |
| CEvpackSignature | Fixed-size detached publisher signature stored in a v1 runtime pack |
| CEvpackSignatureVerifier | Runtime trust provider supplied by the application/project policy |
| CEvpackSigner | Tool-side provider that signs the authenticated 32-byte package metadata digest |
| CEvpackTrust | Trust inputs kept separate from size/resource limits |
| CEvpackUnmountReceipt | Receipt proving one generation was atomically unmounted |
| CEvpackVariant | Capability-addressed runtime representation; list order is fallback order |
| CEvpackVariantSelection | Result of ordered capability variant selection |
| CFileEvpackRangeSource | Thread-safe file-backed range source; each request owns its file stream |
| CPackagePublishReceipt | Durable information returned only after atomic replacement succeeds |
| CPreparedEvpackMount | Owning admitted mount candidate that has not changed observable registry state |
| CRuntimeAssetChunk | One decoded runtime chunk with its admitted semantic metadata |
| CRuntimeAssetPayload | Owning backend-neutral payload returned to a domain decoder |
| CRuntimeDefinitionLimits | Structural and allocation limits for untrusted EVDEF metadata |
| CShaderAsset | Owning CPU program snapshot; decoding does not prove GPU/descriptor compatibility |
| CShaderAssetLimits | Admission bounds checked before copying stage words |
| CShaderAssetParameter | One sequential float/vector push-constant parameter, owned by the definition |
| CSpriteAnimationClip | Immutable validated sprite timeline. No GPU/ECS objects, scheduler, callbacks or mutable playback clock. @ownership Owns frame metadata; snapshots remain valid independently of the clip or source package. @thread Const sampling is worker-safe. Callers supply finite nonnegative elapsed seconds. @reentrancy No callbacks or locks. Reimport builds a new candidate without mutating existing clips |
| CSpriteAnimationFrame | Owning sprite key snapshot; pixel rectangles and pivots use top-left coordinates |
| ►Nasset_graphics | |
| ►Ndetail | |
| CCookedMaterial | Validated material value; image references own identity, GPU bindings initially empty |
| CEvpackGraphicsLoader | Capability-aware adapter from admitted .evpack assets to graphics resources |
| CEvpackImageLoader | Capability-aware adapter from admitted EVIMG assets to backend textures |
| ►CEvpackShader | Unique lease on a validated package shader and its independent parameter instance. @ownership Graphics owns the allocation and must outlive this lease; destroy/release leases before backend shutdown. @lifetime No resource pointer escapes. Draw inputs are borrowed only during the call. Reload builds a new lease. @thread Load, update, draw, release and destruction are graphics-thread affine, outside callbacks/reentrancy |
| CImpl | |
| ►CEvpackStaticPrefab | Owning static-prefab GPU leases and immutable draw transforms; no ECS or Scene mutation. @ownership Mesh/image factories must outlive this object and its explicit release; the factories own GPU allocations. @lifetime Release before backend shutdown/device loss. Reimport builds a separate candidate; swap only after success. @thread Creation, drawing, release and destruction are graphics-thread affine. @reentrancy No scripts or caller callbacks and no locks; do not reenter from backend methods |
| ►CImpl | |
| CDraw | |
| CEvpackVegetationSceneLoader | Strict capability-aware decoder for eve.vegetation-scene/1 |
| CEvpackVolumeTextureLoader | Capability-aware loader for canonical volume-texture/1 assets |
| CGraphicsAssetLoadLimits | Bounds applied before allocating canonical mesh staging arrays |
| CGraphicsImageFactoryAdapter | Result-based adapter over the engine's established graphics resource factory |
| CGraphicsMeshFactoryAdapter | Result-based adapter over the engine's established graphics resource factory |
| CLoadedGraphicsImage | Successfully uploaded texture and selected capability variant |
| CLoadedGraphicsMesh | Successfully uploaded backend mesh and the selected package variant |
| CLoadedGraphicsVolumeTexture | Successfully uploaded volume texture and selected capability variant |
| CLoadedVegetationScene | Fully validated, detached scene-manager candidate with no archive or GPU borrows |
| CStaticPrefabGpuPart | One prefab renderer registered in backend GPU-driven tables |
| ►CVegetationAsset | Owning decoded TVE rest geometry, independent of archive and GPU resource lifetimes. Immutable after construction. CPU evaluation permits concurrent readers; GPU calls require the graphics owner thread. No callbacks or external pointers are retained |
| CImpl | |
| CVegetationSceneAssociation | Owning decoded result of one unique source-GUID scene-manager association |
| CVegetationSceneAssociationLoader | Resolve a Scene Template to exactly one manager asset in the same admitted EVPACK |
| CVegetationSceneChannelGpuBuild | Detached inputs for one independently sized TVE manager channel |
| CVegetationSceneControl | Owning TVE Global Control values; texture identities remain source-map GUIDs |
| CVegetationSceneElement | One normalized Unity TVEElement definition awaiting texture realization |
| CVegetationSceneElementHandle | Instance-qualified handle for one dynamically registered TVE Element volume |
| CVegetationSceneElementPixel | Detached TVE render-target source value and independent hardware blend policy |
| CVegetationSceneElementPixelInput | Explicit per-draw inputs consumed by one TVE Element fragment evaluation |
| CVegetationSceneElementProperty | One normalized Unity TVEElement definition awaiting texture realization |
| CVegetationSceneElementPublication | Receipt for one published dynamic Element registration or withdrawal |
| CVegetationSceneGpuBuild | Explicit detached inputs for publishing all nine TVE scene-manager field layers |
| CVegetationSceneGpuPublication | Receipt for one atomic scene-manager GPU replacement |
| CVegetationSceneGpuRuntime | Owning GPU publication of one immutable TVE manager scene. The resource factory, mask map and scene are borrowed only while create executes. The returned runtime owns the field textures and projected material snapshot. It must outlive every draw borrowing surface() |
| CVegetationSceneInstance | Owning executable instance coupling one Scene Template, its manager fields and live Element registry. GPU resources are graphics-thread affine. Base material texture pointers remain borrowed and must outlive this instance |
| CVegetationSceneLiveElements | Owning registry that atomically couples dynamic Element state to a scene GPU runtime. Imported Elements remain immutable. Dynamic slots use generation-qualified handles and stable slot order. The registry and GPU runtime are graphics-thread affine; no callback is invoked while state is changing |
| CVegetationSceneMotion | Owning TVE Global Motion values; time is supplied by each frame |
| CVegetationSceneProjection | Detached PBR and CPU-motion snapshot ready for atomic material publication |
| CVegetationSceneVolume | Owning TVE Global Volume policy; render resources are allocated by the runtime host |
| CVegetationSceneVolumeChannel | One TVE volume texture channel allocation policy |
| CVolumeTextureAssetLoadLimits | Bounds checked before backend volume allocation |
| ►Nasset_import | |
| ►Ngltf | |
| CAccessor | Borrowed validated accessor; its source document/resources must outlive synchronous reads |
| CDocument | Owning parsed document; keep alive while resolved buffer spans are used |
| CAssetImportLimits | Parser and allocation budgets applied to untrusted importer inputs |
| CCanonicalScatterRule | One deterministic terrain scatter rule, independent of source engine nodes |
| CCanonicalTerrainDetailPrototype | One source vegetation prototype shared by baked terrain instances |
| CCanonicalTerrainInput | Fully parsed source terrain ready for canonical archive construction |
| CCanonicalTerrainInstance | One baked instance in canonical right-handed metre coordinates |
| CCanonicalTerrainLayer | One canonical terrain material layer after source-engine mapping |
| CGltfImportRequest | Untrusted .gltf/.glb input plus explicitly supplied external URI bytes |
| CImageImportRequest | Untrusted encoded image input and its explicit semantic settings |
| CImportFinding | One auditable source-feature outcome emitted by an importer |
| CImportPackageIdentity | Common stable package metadata supplied by an import transaction |
| CImportSourceMapping | Stable source object to canonical asset identity mapping for reimport diagnostics |
| CLegacyAnimationImportRequest | Owning request for the non-production EVA 1 animation text fixture |
| CPreparedAssetImport | Owning, validated source archive candidate not yet published to disk/database |
| CUnityExpandedPrefab | Owning import-only expansion; original source bytes remain authoritative for archival |
| CUnityProjectImportRequest | In-memory Unity project slice; keys are normalized project-relative paths |
| CUnitySourceAsset | Immutable-by-convention owning source index entry; no borrowed source addresses |
| CUnitySourceIndex | Owning deterministic index sorted by path, plus missing-reference diagnostics |
| CUnitySourceReference | External serialized object identity. fileId is signed, as in Unity serialization |
| CUnityVegetationAssetImportRequest | Owning inputs for one atomically prepared Unity vegetation asset group |
| CUnityVegetationBatchImportRequest | Owning ordered set of independently converted vegetation objects published as one package |
| CUnityVegetationConversionRequest | Owning inputs for one complete Unity Material and TVE preset conversion transaction |
| CUnrealProjectImportRequest | Uncooked Unreal content slice plus a versioned data-only adapter descriptor |
| CVegetationConversionCandidate | Owning unpublished material, mesh and texture candidate mutated transactionally by preset commands |
| CVegetationConversionResult | Complete detached output of one vegetation preset conversion transaction |
| CVegetationPresetCommand | One evaluated TVE conversion command in source execution order |
| CVegetationPresetContext | Immutable source facts used by TVE preset predicates |
| CVegetationPresetImage | Owning linear RGBA8 source or packed texture used by preset conversion |
| CVegetationTextureChannelRecipe | One channel instruction in a TVE packed-texture recipe |
| CVegetationTexturePackRecipe | One ordered texture packing recipe produced by preset execution |
| ►Nasset_physics | |
| CEvpackClothModelLoader | Capability-aware adapter from admitted .evpack data to ClothModel |
| CLoadedClothModel | Successfully decoded cloth model and selected package variant |
| ►Nasset_procgen | |
| CEvpackInstanceSetLoader | Capability-aware eve.instance-set/5 EVINST decoder with v1-v4 compatibility |
| CEvpackPointGraphLoader | Capability-aware loader for compiled eve.pcg-graph/1 execution plans |
| CEvpackTerrainLoader | Capability-aware decoder from eve.terrain/1 to procgen terrain data |
| CEvpackTerrainMaterialLoader | Strict eve.terrain-material/3 EVDEF loader with one-version compatibility |
| CInstanceSetLoadLimits | Bounds applied before allocating untrusted instance records and strings |
| CITerrainVegetationGpuResolver | Provider boundary from stable prototype names to backend table slots |
| CLoadedInstanceSet | Owning exact static-instance set selected for one runtime variant |
| CLoadedPointGraph | Owning executable graph and its selected output node |
| CLoadedTerrain | Owning heightmap plus queryable procgen spatial representation |
| CLoadedTerrainMaterial | Owning capability-selected terrain material candidate |
| CPackedTerrainMaterialAtlases | Single-draw terrain textures covering up to sixteen layers |
| CPackedTerrainMaterialGpuSet | Backend-owned texture set for a single draw of up to sixteen layers |
| CRuntimeInstance | One exact canonical static instance using meters and an XYZW quaternion |
| CRuntimeInstancePrototype | Runtime vegetation prototype metadata retained from the source terrain |
| CRuntimeTerrainLayer | One owning canonical terrain layer independent of its source engine |
| CTerrainAssetLoadLimits | Explicit resource limits applied before terrain allocation |
| CTerrainAtlasImage | Owning base-level linear RGBA8 image ready for backend upload |
| CTerrainDetailCardGeometry | Owning unit geometry whose instance transform supplies Unity's exact width and height |
| ►CTerrainDetailGpuResolver | Owning lazy GPU resource resolver for texture-backed terrain Detail prototypes. @ownership Uploaded meshes and images are owned by the bound Graphics backend and leased by this resolver. @lifetime The reader and Graphics backend must outlive this object and its explicit release. @thread Construction, resolve, release, and destruction are graphics-thread affine. @reentrancy Calls no scripts or caller callbacks and must not be entered recursively |
| ►CImpl | |
| CResource | |
| CTerrainDetailRuntime | Owning runtime for one cooked Unity Terrain Detail instance set. @ownership Owns the realization, GPU resolver leases, and render registration. @lifetime The reader and Graphics backend passed to load must outlive this object and release. @thread Load, frame updates, rendering callbacks, release, and destruction are graphics-thread affine. @reentrancy Calls no scripts; release must not run from a render callback |
| CTerrainMaterialAtlases | Complete terrain material image set; up to four groups cover sixteen layers |
| CTerrainMaterialAtlasGroup | Four-layer atlas group driven by one RGBA control image |
| CTerrainMaterialAtlasLimits | Bounds for deterministic terrain atlas construction |
| CTerrainMaterialGpuGroup | Four backend-owned textures for one uploaded terrain group |
| CTerrainMaterialGpuSet | Backend-owned terrain textures released together on their graphics thread |
| CTerrainMaterialLoadLimits | Admission budgets for terrain material definitions |
| CTerrainVegetationBucket | Contiguous prototype range suitable for one instanced render submission |
| CTerrainVegetationGpuFrame | Explicit frame inputs for deterministic terrain Detail animation |
| CTerrainVegetationGpuPlan | Detached CPU upload plan accepted by both Vulkan and WebGPU GPU-driven paths |
| ►CTerrainVegetationGpuPrototype | GPU table slots resolved for one vegetation prototype |
| CPart | Part public API |
| CTerrainVegetationGpuPrototypeRequest | One owning realization's prototype request passed to the graphics resource provider |
| CTerrainVegetationInstance | One stable terrain vegetation transform and its source attributes |
| CTerrainVegetationLimits | Hard limits for one deterministic terrain vegetation realization |
| CTerrainVegetationRealization | Owning, prototype-sorted result plus scalability evidence |
| ►CTerrainVegetationRenderer | Own one realized terrain Detail set and submit it from RenderSystem3D's forward phase |
| CState | |
| CTerrainVegetationWeightDomain | Explicit world-to-control-map projection for terrain layer filtering |
| ►Nasset_scene | |
| CEvpackSceneTemplateLoader | Capability-aware scene-template/3 decoder with explicit scene-template/2 compatibility |
| CLoadedSceneTemplate | Owning declarative scene tree and render bindings; neither mutates a Scene or retains GPU objects |
| CSceneMeshBinding | Immutable asset identities associated with a persisted scene node; no runtime objects are retained |
| CSceneTemplateLoadLimits | Bounds for untrusted scene-template metadata |
| ►Nasset_stylize | |
| ►CEvpackMeshVfx | Owning package-backed mesh effect, using the canonical MeshVfxAsset playback and curves. @ownership Owns playback and shader leases. Graphics must outlive it; destroy before device shutdown. @lifetime Mesh/texture inputs are never retained. Load/reload copy package data; readers may be destroyed immediately. @thread Graphics-thread affine, no callbacks, locks or reentrancy. Time comes exclusively from advance(dt) |
| CImpl | |
| ►Nattributes | |
| CAttributeModifier | One canonical runtime modifier applied to one named attribute |
| CAttributeOperationRegistry | Registry for explicitly named custom attribute policies |
| CAttributeProjection | Canonical selected-attribute storage with owner and revision checks |
| CAttributeProjectionSnapshot | Transaction-safe snapshot of selected attributes and their modifiers |
| CAttributeResourceAccountAdapter | Restricts one AttributeSetResourceAccount to Mana or Stamina |
| CAttributes | Generic named numeric attributes and modifier module |
| CAttributeSet | Generic owning collection of canonical attributes and modifiers |
| CAttributeSetResourceAccount | Adapts integral AttributeSet base values to IResourceAccount |
| CAttributeSetStateAdapter | Adapts one AttributeSet to numeric world reads and volatile writes |
| CAttributeSnapshotBase | One base value captured by an attribute projection snapshot |
| CAttributeValue | Runtime value and modifiers for exactly one attribute |
| CParsedAttributeOperation | Parsed legacy operation and its normalized value |
| ►Naudio | |
| CAudio | OpenAL audio module: device management, master listener state, and Source factory. Script: audio <- eve.Audio(); |
| CAudioZoneItem | One Pcg audio-zone track timing and gain profile |
| CAudioZoneOutput | Commands to apply to a caller-owned audio Source |
| CAudioZoneProfile | Caller-owned Pcg audio-zone configuration and track list |
| CAudioZoneState | Persistent playback state owned by the caller |
| CPcmChunk | 解码后待排队的一帧 PCM 数据。 |
| CSource | A playable audio source (static buffer or streaming decoder). Not thread-safe for playback control except fillPendingFromDecoder(), which is synchronized for the Audio worker thread |
| ►Naudio_editing | |
| CAudioAuditionTransport | Revision-safe play/pause/seek/custom-loop state machine for asset audition |
| CAudioBusSnapshot | Immutable mixer bus snapshot for hierarchy and routing panels |
| CAudioChannelInspection | Per-channel audio signal statistics |
| CAudioEffectChainPublisher | Rejects invalid/stale chains before runtime publication |
| CAudioEffectChainTarget | Revisioned reversible serial effect chain independent of an audio backend |
| CAudioEffectRecord | Stable effect instance with normalized dry/wet mix and typed parameters |
| CAudioImportDiagnosticsService | Codec-neutral signal and import-budget diagnostics for decoded PCM |
| CAudioImportInspectionRequest | Import metadata and policy supplied before audio publication |
| CAudioImportInspectionResult | Revision-tagged codec/import QA and memory recommendation |
| CAudioMixerTarget | Serializable mixer-bus hierarchy, including master bus |
| CAudioSourcePublishingTarget | Operation target coupling an owned audio document to an atomic live sink |
| CAudioSourceTarget | Serializable audio-source authoring target independent of OpenAL handles |
| CAudioSourceTransportBackend | Non-owning transport backend for a live OpenAL-backed audio Source |
| CAudioTransportSnapshot | Immutable revision-tagged audition playhead observation |
| CAudioWaveformBucket | One min/max/RMS envelope bucket for a single channel |
| CAudioWaveformRequest | Immutable waveform request tied to an audio document revision |
| CAudioWaveformResult | Revision-tagged waveform and loop-preview diagnostics |
| CAudioWaveformService | Codec-neutral waveform generation and loop QA service |
| CEditorAudioPcm | Decoded interleaved PCM supplied by an audio importer or codec plugin |
| CIAudioEditingFactory | Open capability for constructing audio authoring targets without editor type switches |
| CIAudioEffectChainSink | Runtime backend boundary for atomic effect-chain publication |
| CIAudioSourceRuntimeSink | Atomic runtime publication boundary for one authored audio source |
| CIAudioTransportBackend | Minimal playback backend boundary used by the deterministic transport controller |
| ►Naudio_editor | |
| CAudioClockTransportBackend | Clock-backed audition used when no live OpenAL Source is attached |
| ►CAudioEditorModule | Composition adapter that contributes audio editing commands, automation targets, and the script-owned AudioSourceEditor factory |
| CTargetFactory | |
| ►CAudioSourceEditor | Timeline-style controller for one authored audio source |
| CLiveAudition | |
| ►Nauthority | |
| CAuthority | Script module factory for generic authority stores |
| CAuthorityStoreHandleTag | Handle domain for module-owned authority stores |
| CDecision | Explainable result of an authority decision |
| CEvent | Deterministically sequenced authority lifecycle event |
| CRule | One stable authority rule over an opaque actor and scope |
| CStore | Generic, deterministic capability authority store |
| ►Navatar | |
| CAvatar | Avatar module — layered character rendering for VN / portrait use. Script: avatar <- eve.Avatar(); |
| CAvatarInstance | Unified avatar instance. Kind is a string: "image" | "live2d" | "vroid". Script-facing API avoids overloads; kind-specific methods no-op / return false when unsupported |
| CILive2DBackend | Optional Live2D runtime backend (Cubism etc.). Registered from C++ / plugins |
| CNullLive2DBackend | Built-in Live2D placeholder backend (no Cubism SDK). Stores path / parameters / expression / motion so scripts and tests can run without a proprietary runtime. Replace via Avatar::registerLive2DBackend (see examples/live2d-backend-plugin) |
| CVrmAtlasRect | VrmAtlasRect public API |
| CVrmCollider | Node-local sphere/capsule used only by referencing spring groups |
| CVrmDocument | Validated VRM schema data. Unknown optional fields are ignored; unknown versions fail |
| ►CVrmExpression | One expression's indexed morph/material/UV operations |
| CColor | Color public API |
| CMorph | Morph public API |
| CUv | Uv public API |
| ►CVrmLookAt | VRM gaze maps; angles are degrees, expression outputs are weights |
| CRange | Range public API |
| CVrmMaterial | Linear material factors and image references from VRMC_materials_mtoon |
| ►CVrmRuntime | VrmRuntime public API |
| CPart | Part public API |
| ►CVrmSpring | Ordered joints and explicit collision membership of one VRM spring |
| CJoint | Joint public API |
| CVrmSurface | VrmSurface public API |
| CVrmTexture | Owning, validated VRM import data; independent of parser and source bytes |
| ►Navatar_editing | |
| CAvatarDocumentRuntime | Candidate-first live AvatarInstance generation |
| CAvatarDocumentTarget | Revisioned image/Live2D/VRoid Avatar authoring asset |
| CAvatarExpressionValue | Named expression containing layer/parameter channel targets |
| CAvatarLayerValue | Stable image layer in an Avatar asset |
| CAvatarParameterValue | Reflected Avatar parameter and its initial value |
| CIAvatarTextureResolver | Resolves image-layer textures for candidate publication |
| ►Navatar_editor | |
| CAvatarDocumentEditor | Timeline-style controller for one authored avatar document |
| ►CAvatarEditorModule | Composition adapter that contributes avatar editing commands and automation targets |
| CTargetFactory | |
| ►Nbiome_editing | |
| CBiomeAssetValue | Stable weighted asset entry in one biome layer |
| CBiomeDocumentRuntime | Candidate-first BiomeRules generation |
| CBiomeDocumentTarget | Revisioned BiomeRules asset |
| CBiomeLayerValue | Stable authored biome layer referencing a spatial asset |
| CIBiomeSpatialResolver | Resolves copied spatial domains for BiomeRules publication |
| ►Nbiome_editor | |
| ►CBiomeEditorModule | Composition adapter that contributes biome editing commands and automation targets |
| CTargetFactory | |
| CBiomeRulesEditor | Workspace controller for one authored biome rules document |
| ►Nbuilding | 建筑放置模块入口：定义 / 放置世界 / 鬼影 / 变更事件的脚本绑定点。 设计文档：docs/dev/建筑放置系统设计.md |
| CBuilding | 建筑放置模块（eve.Building）。 |
| CBuildingChangeEvent | 一次成功放置变更的事件（供脚本 poll / C++ hook）。 |
| CBuildingDefinition | 建筑模板（进程级注册表中的定义）。 |
| ►CBuildingGarrisonContainerAdapter | Transactional adapter over one placed building's authoritative garrison |
| CPreparedState | |
| CBuildingGarrisonContainerObject | Owning payload carrying a garrison member's domain facts |
| CBuildingRegistry | EVENGINE_API_WORLD public API |
| CCornerAddress | Canonical address of one logical grid vertex used by corner objects |
| CEdgeAddress | Canonical address of one grid edge |
| CEdgeCurveControlPoint | One cubic Bezier control point in logical grid-vertex space |
| CEdgeCurveGroup | World-owned authoritative description and membership of one committed edge curve |
| CEdgeCurveGroupId | Strong world-local identity of one authoritative edge-curve group |
| CEdgeCurveSurfaceSample | One committed 3D centerline frame sampled from a custom placement surface |
| CGarrisonMember | One persistent member of a placed building's logical garrison |
| CGhost | EVENGINE_API_WORLD public API |
| ►CHeightfieldSurface | Immutable regularly sampled heightfield usable as an XY or XZ placement surface |
| CConfig | Owning construction data. Samples are row-major plane-axis heights |
| CPlacedBuilding | 已放置的建筑实例。 |
| CPlacementEditReceipt | Owning before/after receipt produced by one committed placement edit |
| CPlacementQuery | 校验上下文：传给可插拔规则。 |
| CPlacementSession | EVENGINE_API_WORLD public API |
| ►CPlacementSystem | EVENGINE_API_WORLD public API |
| CAreaCellPreview | One requested area anchor and its deterministic validation result |
| CAreaPlacement | Atomic receipt for a committed area placement |
| CAreaPreview | Owning row-major preview for a rectangular or circular brush request |
| CEdgeCurveSurface | Owning same-identity surface frames sampled along an analytic edge curve |
| CEdgeLinePlacement | Atomic result of placing one axis-aligned continuous edge line |
| CEdgePathPlacement | Atomic result of placing one multi-segment edge path |
| CEdgePathPreview | Owning validated edge addresses for one non-mutating path preview |
| CPatternPlacement | Atomic placement receipt shared by every built-in pattern kind |
| CPatternPreview | Owning non-mutating expansion of an edge or area pattern |
| CPatternRequest | Owning, renderer-neutral request for one atomic placement pattern |
| CPlacementHit | One sampled point and orthonormal frame on a placement surface |
| CSurfacePatch | Surface samples and continuity metrics for one rotated building footprint |
| CSurfacePatchSample | One footprint-relative surface sample |
| CPlacementWorld | 格子型建筑放置世界（脚本可直接操作）。 |
| CSnapResult | 吸附结果。 |
| ►CStaticMeshSurface | Immutable world-space triangle mesh accelerated for placement-surface projection |
| CConfig | Immutable identity, hit policy and metadata for one static mesh snapshot |
| CStructuralLinkRebuildReceipt | Result metadata for an atomic rebuild of all derived structural links |
| CStructuralRemovalReceipt | Owning record of one committed dependent-first structural removal |
| ►Nbuilding_editing | |
| CBuildingEdgeCurveDragPreview | Immutable result of one curve-handle pointer update |
| CBuildingEdgeCurveDragSession | UI-neutral ray picking and drag state for one existing cubic building curve. @ownership Borrows the target; the caller must end/cancel before destroying it. @thread Viewport/editor thread only; callbacks are not retained or invoked |
| CBuildingEdgeCurvePoint | Runtime-neutral cubic Bezier control point in logical grid-vertex space |
| CBuildingEdgeCurvePreview | Immutable revision-tagged result for one interactive cubic curve draft |
| CBuildingEdgeCurvePreviewEdge | One canonical edge emitted by a curve draft preview |
| CBuildingEdgeCurveSurfaceSample | Owning world-space center and normal sampled for a surface curve draft |
| CBuildingEdgePathVertex | Runtime-neutral logical vertex used to author an orthogonal edge path |
| CBuildingFootprintCell | One occupied or rejected footprint cell in a placement preview |
| CBuildingGarrisonMemberRecord | Persistent garrison member copied through building editor undo |
| CBuildingInstanceSnapshot | Complete runtime-neutral placed-building snapshot |
| CBuildingPlacementPreview | Structured footprint/snap preview tied to a world revision |
| CBuildingPlacementTarget | Live PlacementWorld target with reversible place/move/remove operations |
| ►Nbuildingfx | |
| ►CBuildingFx | EVENGINE_API_WORLD public API |
| CCurveControlPoint | One cubic Bezier control point in logical grid-vertex coordinates |
| CCurveMeshData | Owning backend-neutral indexed extrusion generated along an edge curve |
| CCurveSurfaceSample | One committed world-space centerline frame for terrain-conforming extrusion |
| ►Ncamera | |
| CCamera | 摄像机模块命名空间（eve.Camera）。主要职责是把 CameraController 绑定进脚本。 |
| CCameraController | 3D 摄像机控制器（eve.Camera / eve.CameraController）。 |
| CPcgCarCameraProfile | Serializable values matching Pcg CarControllerSetup camera defaults |
| CPcgCarCameraSetup | Caller-owned Pcg vehicle orbit-camera setup and input adapter |
| CPcgFreeCamera | Caller-owned six-degree free-camera state ported from Pcg FreeCamera |
| CPcgFreeCameraInput | Device-independent input snapshot for Pcg free-camera movement |
| CPcgPhotoModePostFxState | Complete Pcg photo-mode post-processing state retained across render-pipeline projections |
| ►Ncamera_editing | |
| CCameraDocumentRuntime | Candidate-first bridge from camera assets to CameraController |
| CCameraDocumentTarget | Revisioned camera-rig and director-timeline editing document |
| CCameraPreview | Deterministic scrub evaluator and camera/frustum gizmo producer |
| CCameraPreviewPose | Renderer-neutral camera pose sampled from an authored timeline |
| CCameraRigValue | Stable authored camera rig independent of a live scene camera |
| CCameraTimelineKeyValue | Stable camera timeline key (cut, event, or scalar automation) |
| ►Ncap | |
| COwnedProviderHandle | Generation-qualified id for one owned capability provider |
| COwnedProviderLease | Owning lease that keeps a shared_ptr provider alive while borrowed |
| COwnedProviderRegistry | Thread-safe owned-provider table keyed by capability name + provider id |
| CProviderRef | One-shot borrowed capability pointer for composition roots and hot paths |
| ►Ncaps | |
| CIAssetReloader | EVENGINE_API_FOUNDATION public API |
| CIAsyncWorkExecutor | Fire-and-forget CPU job submission used by the resource cache |
| CIGpuInfo | EVENGINE_API_FOUNDATION_INLINE public API |
| CIMainThreadPost | EVENGINE_API_FOUNDATION_INLINE public API |
| CIStateProvider | Runtime-state serialization for state hot reload |
| ►Ncard | |
| CCard | 卡牌模块入口（eve.Card）：定义注册、对象工厂与每帧 update/render。 |
| CCardAttributeAdapter | Adapts CardData's attack/health values to the canonical AttributeSet |
| ►CCardContainerAdapter | Exposes one card collection through the generic atomic transfer API |
| CPreparedState | |
| CCardContainerObject | Generation-qualified reference to one CardData object |
| CCardControl | Exposes published card hands through the shared gameplay protocol |
| ►CCardData | 单张卡牌：ECS 实体，数据拆成 Identity / Stats / Visual / Layout / State。 |
| CAttributes | Canonical selected card stats backed by the attributes module |
| CDefinitionBinding | Definition link and reload policy for this card instance |
| CEffects | Canonical effect lifecycle and card combat target state |
| CIdentity | 稳定实例 id、显示名、种类。 |
| CLayout | 运行时布局（由 Hand 维护）：中心坐标与变换。 |
| CState | 运行时交互状态。 |
| CStats | 费用 / 攻击 / 生命。 |
| CVisual | 朝向、禁用、色调、卡图。 |
| CCardDefinition | 卡牌类型定义（registerCardsFromJson 注册）。 |
| CCardDefinitionRuntime | Binds a typed card runtime to one Definitions registry incarnation |
| CCardEffectAdapter | Card adapter composing the common lifecycle container with CardEffectExecutor |
| CCardEffectDefinition | Strong card definition projected into the common effect definition |
| CCardEffectExecutor | Card executor: interprets card policy without owning effect instances |
| CCardEffectSnapshot | Serializable in-memory card effect snapshot |
| CCardEffectTarget | Mutable card combat state changed by the card effect executor |
| CCardEffectUpdate | Result of one card effect lifecycle step and its domain settlement |
| CCardEvent | 一次交互事件。 |
| CCardPlaneMapper | Maps a logical card canvas to a 3D parallelogram without depending on graphics |
| CCardPlayComposition | Optional cross-domain operations that belong to one card play |
| CCardPlayConditionAdapter | Evaluates one card play condition without moving or mutating a card |
| CCardPlayConditionContext | Read-only EvaluationContext backed by one card instance and definition |
| CCardPlayConditionQueries | Read-only extension points used while evaluating a card play |
| CCardPlayParticipant | Transaction participant that publishes one CardData play |
| CCardPlayPaymentAdapter | Connects a card's mana field to the owning player's resource account |
| CCardPlayRequest | Complete caller-owned input for one atomic card play |
| CCardPresentationSnapshot | Immutable presentation data captured from one card for external 2D/3D adapters |
| CCardRuntimeState | Typed mutable values owned by one card definition instance |
| ►CDeck | 牌库（栈顶在末尾）。 |
| CMembership | 有序牌堆；栈顶在 vector 末尾。 |
| ►CHand | 手牌：扇形布局 + 悬浮 + 拖拽 + 落区判定 + 渲染。 |
| CDrag | 拖拽内部状态（勿直接修改）。 |
| CMembership | 有序手牌列表。 |
| CMeta | 所有者与布局/交互开关。 |
| CLayoutConfig | UiCard 风格的布局配置（脚本可实时修改，对应 UiCard 的 Configs 面板）。 |
| ►CZone | 落牌区（手牌区 / 出牌区 / 弃牌区），用于拖放命中判定。 |
| CFilter | 接受的卡牌 kind；空 = 接受任意 kind。 |
| CRect | 区域矩形与绘制参数。 |
| ►Nclimbing | |
| ►Ndetail | |
| CClimbingAnchorAgentIdTag | ClimbingAnchorAgentIdTag public API |
| CClimbingAnchorReservationIdTag | ClimbingAnchorReservationIdTag public API |
| CClimbingExecutionIdTag | ClimbingExecutionIdTag public API |
| CClimbingServiceSubjectTag | ClimbingServiceSubjectTag public API |
| CClimbingStaminaReservationTag | ClimbingStaminaReservationTag public API |
| ►Nruntime_detail | |
| CRuntimeTelemetryScope | RuntimeTelemetryScope public API |
| CWarpChannels | WarpChannels public API |
| CBufferedClimbingCommand | One owning edge command with deterministic lifetime and consumption evidence |
| CClimbing | Script-facing factory and owner for independent climbing runtimes |
| CClimbingActionDefinition | Definition of one geometry-compatible climbing action |
| CClimbingAdvance | Owning output of one execution tick |
| CClimbingAnchorAuthoringOverlay | Bounded owning editor snapshot; consumers may render it without retaining graph pointers |
| CClimbingAnchorBakeRequest | Complete owning input transaction for deterministic anchor-graph baking |
| CClimbingAnchorBakeResult | Measured bake result used by tools and build telemetry |
| CClimbingAnchorBakeSettings | Settings whose canonical values participate in the baked graph build hash |
| CClimbingAnchorEdgeDefinition | Directed authored transition in a climbing anchor graph |
| CClimbingAnchorGraphDefinition | Versioned graph asset; topology is authoritative while collision remains owned by Physics |
| CClimbingAnchorGraphHandleTag | Handle domain for module-owned anchor graph runtime instances |
| CClimbingAnchorGraphInstance | Runtime instance binding one immutable graph generation to one Physics body |
| CClimbingAnchorGraphReload | Atomic graph-reload outcome and owners whose old-generation reservations were invalidated |
| CClimbingAnchorNodeDefinition | One body-local anchor node with deterministic occupancy slots |
| CClimbingAnchorNodeRef | Generation-qualified reference to an authored anchor node |
| CClimbingAnchorOccupant | Compound occupancy owner; execution ids are only unique inside one agent/runtime |
| CClimbingAnchorOverlayEdge | One renderer-neutral directed edge primitive in a body-local editor overlay |
| CClimbingAnchorOverlayNode | One renderer-neutral node primitive in a body-local editor overlay |
| CClimbingAnchorReservation | Owning reservation credential; release validates every field |
| CClimbingAnchorRoute | Shortest deterministic route pinned to one graph generation |
| CClimbingAnchorRouteRequest | Read-only route request over one current anchor-graph generation |
| CClimbingAnchorRouteStep | One owning directed edge in a planned anchor route |
| CClimbingAnimationBinding | Stable animation asset and graph binding metadata |
| CClimbingAnimationFrame | Owning result of extracting one animation frame for authoritative climbing motion |
| CClimbingBody | Hot authoritative transient motor component; replicated by value for prediction |
| CClimbingBranchWindow | Normalized branch interval advertising one stable combo tag |
| CClimbingCandidate | Owning, replayable climbing candidate; contains no borrowed query pointers |
| CClimbingCandidateBuffer | Fixed-capacity owning candidate projection written once per PrePhysics probe phase |
| CClimbingCandidateEvidence | Quantized selection cost and hard-decision evidence for one action definition |
| CClimbingCandidateKey | Opaque deterministic identity of one sorted candidate; contains no client-authored position |
| CClimbingCandidateSet | Fixed-capacity owning candidate set used by the production probe hot path |
| CClimbingContactConstraint | Normalized contact interval and maximum constraint weight |
| CClimbingControl | Exposes server-probed climbing actions without accepting authored world targets |
| CClimbingDebugQuery | Geometry-query evidence suitable for an engine debug-draw adapter |
| CClimbingDebugSnapshot | Bounded owning debug snapshot, independent of Physics query caches |
| CClimbingEcsSelectionSystem | PrePhysics selection/commit consumer over caller-selected domain entities |
| CClimbingEvent | Owning event record; dispatch to scripts only after the simulation phase |
| CClimbingEventBatch | Bounded owning post-simulation event batch safe to dispatch after the ECS View closes |
| CClimbingGraphState | Non-authoritative graph projection state; contains no borrowed pointers |
| CClimbingInputSystem | Input-phase operations over a ClimbingIntent component |
| CClimbingIntent | Hot authoritative intent component; contains no device or callback pointers |
| CClimbingLadderBakeSource | Body-local ladder description supplied by an editor geometry extractor |
| CClimbingLedgeBakeSource | Ordered body-local ledge samples supplied by an editor geometry extractor |
| CClimbingLimbChain | Three-bone limb chain used by Animation's built-in TwoBoneIK solver |
| CClimbingLinks | Cold authoritative cross-domain links; handles are resolved on every system step |
| CClimbingLocomotionPolicy | Small owning projection of profile fields consumed by ordinary ground/air locomotion |
| CClimbingMotionEvidence | One planned-versus-actual capsule sample from an authoritative execution tick |
| CClimbingMotionInput | Per-tick authored animation motion supplied before climbing warp and collision |
| CClimbingMotionSystem | Physics-phase authoritative capsule motion consumer |
| CClimbingPose | Input pose used for one deterministic candidate probe |
| CClimbingPoseBinding | Borrowed-pose adapter inputs; no skeleton or pose pointer is retained |
| CClimbingPoseProjection | Derived PostPhysics pose projection; gameplay validity never depends on these weights |
| CClimbingPoseResult | Observable result of applying built-in hand constraints |
| CClimbingPoseSystem | PostPhysics derived pose and owning event-drain producer |
| CClimbingPredictionDecision | Server-to-client decision carrying the authoritative runtime snapshot for reconciliation |
| CClimbingPredictionRequest | Client-to-server request containing selection identity only, never a world-space target |
| CClimbingProbeSystem | PrePhysics candidate producer over a caller-selected existing domain root |
| CClimbingProfileDefinition | Runtime profile controlling capsule geometry and probe limits |
| CClimbingQueryBudgets | Query budgets for one 60 Hz primary-character simulation tick |
| CClimbingRuntime | Owner-thread climbing planner and executor for one character |
| CClimbingRuntimeCounters | Allocation-free counters produced by the latest runtime workload |
| CClimbingRuntimeHandleTag | Handle domain for module-owned climbing runtimes |
| CClimbingScoreWeights | Quantized selection-cost weights stored with a profile |
| CClimbingSelectionSystem | PrePhysics selection transaction joining buffered input to one authoritative execution |
| CClimbingServiceSelectionSystem | Selection transaction that atomically joins external stamina reservation to runtime publication |
| CClimbingServiceStart | Result of a service-aware selection transaction |
| CClimbingStart | Owning evidence returned by one committed climbing selection transaction |
| CClimbingState | Hot authoritative execution component holding the module-owned runtime identity |
| CClimbingSystemContract | Static review/tooling description of one concrete climbing ECS phase |
| CClimbingTelemetryBuffer | Runtime-owned fixed ring of performance samples |
| CClimbingTelemetrySample | One profiler sample; elapsed time is observational and never feeds simulation state |
| CClimbingTelemetrySummary | Fixed percentile summary for one workload without retaining dynamic storage |
| CClimbingWarpWindow | Normalized action interval selecting which motion-warp channels may correct authored motion |
| CIClimbingConditionAuthority | Consumer-owned authority for project-specific condition tags |
| CIClimbingEventSink | Optional post-simulation event adapter; it does not own the runtime event queue |
| CIClimbingPoseAdapter | Optional post-physics Animation/IK adapter consuming derived pose constraints only |
| CIClimbingStaminaAuthority | Consumer-owned stamina reservation contract |
| CResolvedClimbingAnchorNode | World-space projection of a body-local anchor at one synchronous resolve point |
| CScriptClimbingRuntime | ScriptClimbingRuntime public API |
| CVec3 | Small owning world-space vector used at climbing module boundaries |
| ►Ncloth | |
| CCloth | Script-facing owner and factory for 2D, 3D, and GPU cloth runtimes |
| ►Ncmd | |
| ►Nsdk | |
| ►Ndetail | |
| CSha256 | Sha256 public API |
| CBuildArgs | |
| CCleanArgs | |
| CCmdline | 命令行模块（eve.cmd）：run / build / package / test / zip / dev-server 等子命令入口。 |
| CCreateArgs | |
| CDevServerArgs | |
| CDocArgs | |
| CGetArgs | |
| CHandler | One eve <subcommand> handler: CLI setup + argument parsing |
| CLanguageServerArgs | |
| CMcpArgs | |
| CMyFormatter | |
| CPackageArgs | |
| CRegister | 子命令静态注册器（CMD_REG 宏使用）。 |
| CRunArgs | |
| CTestArgs | |
| CZipArgs | |
| ►Ncmdline | Minimal streaming ZIP writer used by eve zip / eve package to produce a PhysFS-mountable game archive (.eve). Entries are DEFLATE-compressed (method 8) using zlib's raw deflate. The output is a standard ZIP readable by PhysFS |
| CZipWriter | 流式 ZIP 写入器：open → addFile×N → finish。 |
| ►Ncombat | |
| ►Nnavigation | |
| CPathfinderCombatNavigationConfig | World/grid projection used by the map-backed combat navigation provider |
| CPathfinderCombatNavigationProvider | Synchronous combat steering provider backed by the canonical map Pathfinder |
| CBodyPartDamageRule | Optional damage rule that multiplies health damage by a body-part key |
| CCombat | Factory module for script-owned deterministic combat runtimes |
| CCombatActionDamageSink | Explicitly registered bridge from Action damage blocks to DamageRuntime |
| CCombatActionWindowState | Authoritative combat projection of active Montage hitbox and invulnerability windows |
| CCombatAttributeAdvance | Owning result of a deterministic regeneration step |
| CCombatAttributeDefinition | Data-driven bounds and deterministic regeneration for one combat attribute |
| CCombatAttributeEvent | Owning event emitted after one attribute mutation commits |
| CCombatAttributeRuntime | Owner-thread authoritative combat attribute coordinator |
| CCombatCameraFraming | Deterministic lock-on framing: look at the midpoint, stand behind the player |
| CCombatCameraFramingRequest | Framing inputs for a two-subject combat camera |
| CCombatCameraView | Owning eye/look-at pair; camera modules apply this without owning combat state |
| CCombatCancelResolution | Owning audit of one resolved cancel or combo transition |
| CCombatCancelResolver | Compose buffered input, cancel/combo windows and ComboGraph without activating abilities |
| CCombatCancelResolveRequest | Inputs for one deterministic cancel/combo resolution |
| CCombatCharacterAdvance | Complete owning result of one character advance |
| CCombatCharacterDefinition | Immutable registration for one action-combat character |
| CCombatCharacterEvent | Owning event emitted by the character controller |
| CCombatCharacterPoseSource | IMeleePoseSource that samples CombatCharacterRuntime position and yaw |
| CCombatCharacterRuntime | Owner-thread 3D character authority for action combat |
| CCombatCharacterState | Owning read-only projection of one character |
| CCombatEnemyDefinition | Owning configuration for one enemy fighter |
| CCombatEnemyIntentSource | Deterministic enemy intent source for arena vertical slices |
| CCombatEnemySteering | Owning planar steering suggestion for Mid/Far bands |
| CCombatLockState | Owning lock-on state for one fighter |
| CCombatLocomotionAdvance | Complete owning result of one committed locomotion frame |
| CCombatLocomotionDefinition | Immutable registration data for one locomotion subject |
| CCombatLocomotionEvent | Owning event emitted after a successful complete locomotion frame |
| CCombatLocomotionRuntime | Owner-thread combat locomotion authority shared by player and navigation commands |
| CCombatLocomotionState | Owning read-only projection of one registered combat subject |
| CCombatLoopFrame | Owning audit of one composed combat frame |
| CCombatLoopRuntime | Owner-thread coordinator that welds combat runtimes for one arena tick |
| CCombatMotionWarp | Pull the attacker toward a standoff distance without exceeding per-tick or remaining budgets |
| CCombatNavigationGoal | Owning navigation goal retained by the locomotion authority |
| CCombatNavigationSteering | Owning output produced by an optional navigation adapter |
| CCombatPerfectDodge | Owning audit that a dodging i-frame negated a melee hit |
| CCombatState | Mutable combat state owned by the gameplay domain for one subject |
| CCombatTargetCandidate | Candidate scored by an external sensing/query adapter |
| CCombatTargetRuntime | Owner-thread lock-on authority |
| CCombatVector2 | Finite position or direction in the horizontal combat plane |
| CCombatVector3 | Finite 3D combat vector |
| CCombatWarpRequest | Input for one deterministic motion-warp solve |
| CCombatWarpResult | Owning warp delta that callers add to root motion or position |
| CComboGraph | Deterministic directed graph of combat ability transitions |
| CComboGraphEdge | Edge that may cancel from one ability into another |
| CComboGraphMatch | Owning match produced by the combo graph |
| CDamageAmounts | Provider result prepared before the authoritative state is mutated |
| CDamageOutcome | Complete owning audit result of one committed damage transaction |
| CDamageRequest | Owning input for one damage transaction |
| CDamageRuntime | Owner-thread deterministic damage coordinator |
| CDirectCombatNavigationProvider | Straight-line obstacle-free provider useful for arenas and deterministic tests |
| CGuardEvaluation | Owning audit of one guard evaluation |
| CGuardWindowState | Authoritative projection of active block/parry Montage windows |
| CHitFeelAdvance | Complete owning result of one feel advance |
| CHitFeelEvent | Owning feel event |
| CHitFeelRequest | Authored freeze/stun durations applied after a damage outcome |
| CHitFeelRuntime | Owner-thread hitstop/hitstun coordinator |
| CHitFeelState | Per-subject freeze or stun remaining after the last commit |
| CHitReactionPolicy | Threshold policy for deterministic reaction selection |
| CICombatGroundProvider | Optional ground-height sampler consumed by the character controller |
| CICombatMoveProbe | Optional capsule move resolver for walls and overlapping bodies |
| CICombatNavigationProvider | Optional synchronous navigation boundary consumed by combat locomotion |
| CIDamageRule | Optional game-owned mitigation/amplification policy |
| CIMeleePoseSource | Optional pose resolver for active hitbox ids |
| CImpulse3 | Renderer/physics-neutral knockback impulse authored in world units |
| CMeleeHitboxDefinition | Catalog entry that maps a timeline hitbox resource id onto geometry |
| CMeleeHitEvent | One confirmed contact produced by a sweep frame |
| CMeleeHitFrame | Complete owning result of one melee advance |
| CMeleeHitRuntime | Owner-thread authority for hurtboxes, hitbox catalogs and sweep hits |
| CMeleeHurtboxDefinition | Body-part tag used for multipliers and debugging |
| CMeleePoint3 | Finite world-space point used by melee geometry |
| CMeleePose | World pose for one shape sample |
| CMeleeShape | Owning geometry definition referenced by a stable hitbox or hurtbox id |
| ►Ncontainer | |
| CBox3D | Axis-aligned 3D box for World3DSpace zones |
| CCapacity | Non-negative capacity measured in membership slots |
| CCircle | Circle public API |
| CContainerDescriptor | Static metadata and acceptance policy of a container |
| CContainerId | Strong identity of one runtime or persistent container |
| CContainerObject | Generic object facts used by filters and transfer diagnostics |
| CContainerObjectPayload | Opaque, owning payload supplied by a domain adapter during transfer |
| CContainerSnapshot | Lossless snapshot of one container at one revision |
| CCoordinate | Coordinate public API |
| CCoordinate< World3DSpace > | Three-dimensional coordinate; z is intentionally mandatory |
| CFilter | Extensible filter result used by container and zone acceptance rules |
| CGridSpace | GridSpace public API |
| ►CIContainer | Borrowed container implementation owned by a domain adapter |
| CPreparedState | Detached state prepared for an atomic container replacement |
| CMembership | One object-to-slot relationship, including the observed generation |
| CMembershipEntry | Complete adapter-owned state used to build a candidate replacement |
| CMembershipId | Strong identity of an object which can have one container membership |
| CRectangle | Rectangle public API |
| CScreenSpace | Coordinate-space tags; distinct types prevent accidental mixing |
| CSlotIndex | Explicit slot number; it never implicitly converts to an integer |
| CSphere3D | Spherical 3D shape for World3DSpace zones |
| CTransferEvent | Strong event payload emitted only after a transfer is fully committed |
| CTransferReceipt | Observable receipt for one committed or explicit no-op transfer |
| CTransferRequest | Requested optimistic-concurrency transfer. All pointers are borrowed |
| CTransferService | Atomic preflight/prepare/commit coordinator for one or two adapters |
| CWorld2DSpace | World2DSpace public API |
| CWorld3DSpace | World3DSpace public API |
| CZone | Shape-bounded, capacity-limited zone in one compile-time coordinate space |
| CZoneShapeTraits | ZoneShapeTraits public API |
| CZoneShapeTraits< World3DSpace > | ZoneShapeTraits public API |
| ►Ncrowd | |
| CAgentInteraction | Independent local interaction policy, copied into Crowd storage |
| CAgentState | 单个单位的状态快照（脚本 getAgentState 返回值）。 action: 0=idle, 1=flow, 2=seek, 3=boids。 |
| CAvoidanceSettings | Optional bounded velocity sampling for RTS local avoidance |
| ►CCrowd | 群体行为模块：连续流场寻路 + 海量单位移动/转向/行动 + Boids 鸟群。 |
| ►CImpl | Private crowd runtime storage. @cost Linear in agent count for SOA vectors and transient broadphase/avoidance work buffers; capacity is bounded by maxAgents |
| CAvoidanceNeighbor | |
| CCrowdField | 连续流场（flow field）。 |
| CFlowVec | 流场采样结果（脚本 flowAtWorld / flowAtCell 返回值）。 |
| CSpawnBatch | Caller-built transaction; positive budgets bound search and relaxation. @cost Linear in requested agents plus bounded candidate/contact checks; callers amortize by batching spawns |
| CSpawnPlacement | Owning placement result, independent of compact slots and subsequent removal |
| CSpawnReceipt | Observations from a committed spawn transaction. @cost Linear in created placement count; returned by value once per spawn batch |
| CSpawnRequest | One named agent to create; all fields are owned values |
| CStepReport | Owning observations of one completed advance; simulation-thread only |
| ►Ncrowd_editing | |
| CCrowdAgentRecord | Stable authoring record for one crowd agent |
| CCrowdDocumentTarget | UI-neutral agent/zone/path document with reversible domain operations |
| CCrowdOverlayPrimitive | Renderer-neutral line, circle and label primitives for AI overlays |
| CCrowdOverlayResult | Revision-tagged deterministic viewport overlay |
| CCrowdPathRecord | Stable ordered path shared by multiple agents |
| CCrowdWaypointRecord | Stable waypoint used by a crowd path |
| CCrowdZoneRecord | Stable polygonal sensing, avoidance or gameplay zone |
| ►Ndata | |
| CByteData | In-memory byte buffer implementing eve::Data (ref-counted) |
| CCompressedData | Stores byte data compressed via DataModule::compress |
| CCompressor | Base class for backends for different compression formats |
| CDataModule | EVENGINE_API_FOUNDATION public API |
| CDataView | Contains a reference to a subsection of an existing Data object |
| ►CHashFunction | EVENGINE_API_FOUNDATION public API |
| CValue | Value public API |
| CJsonDocument | Thin RAII wrapper over a Poco JSON value (object/array/scalar) |
| CLZ4Compressor | |
| CXmlDocument | Thin RAII wrapper over a Poco XML DOM document |
| CzlibCompressor | |
| ►Ndatabase | |
| CConnection | SQLite connection with a small ORM layer on top of Poco::Data. Tables/columns are quoted identifiers; values are bound as literals |
| CDatabase | Database module (eve.Database): SQLite connection factory. Script: db <- eve.Database(); conn <- db.connectSQLite("game.db"); |
| CField | A named field used by the small, explicit ORM mapping layer |
| CMapping | Mapping public API |
| CModel | Runtime ORM model exposed to Squirrel |
| CQuery | Composable filtered/sorted/paged query shared by C++ and scripts |
| CRepository | Typed active-record repository built from a Mapping<T> |
| ►Ndaynight | |
| ►CDayNight | DayNight module — a time-of-day cycle that drives the sun, sky and light |
| ►CImpl | |
| CFly | |
| CPcgAmbientLightState | Pcg ambient-gradient colors and global direct-light multiplier |
| CPcgFogState | Joint Pcg Photo Mode fog and density-volume state |
| CPcgLightingAmbientPhotoMode | Explicit Lighting owner for Pcg ambient colors and global light multiplier. @lifetime The borrowed DayNight target must outlive this authority or be detached first. @thread Game thread only; assignments are synchronous and invoke no callbacks or scripts |
| CPcgLightingFogPhotoMode | Explicit owner for Pcg's fourteen Lighting fog and density-volume fields. @lifetime The borrowed DayNight target must outlive this authority or be detached first. @thread Game thread only; assignments are synchronous and invoke no callbacks or scripts |
| CPcgLightingSkyboxPhotoMode | Explicit Lighting-field owner for Pcg's four skybox override controls. @lifetime The borrowed DayNight target must outlive this authority or be detached first. @thread Game thread only; assignments are synchronous and invoke no callbacks or scripts |
| CPcgLightingSunPhotoMode | Explicit Lighting-field owner for Pcg's six manual-sun controls. @lifetime The borrowed DayNight target must outlive this authority or be detached first. @thread Game thread only; assignments are synchronous and invoke no callbacks or scripts |
| CPcgLightingTimePhotoMode | Explicit Lighting-field owner that projects Pcg time settings into DayNight. @lifetime The borrowed DayNight target must outlive this authority or be detached before destruction. @thread Game thread only; no callbacks or scripts are invoked |
| CPcgManualSunState | Persistent manual sun settings projected from Pcg Photo Mode |
| CPcgSkyboxState | Persistent Pcg skybox override settings |
| CSkyClock | Runtime clock configuration, independent of the legacy DayNight module |
| CSkyCloudMotion | Source cloud-time controls; phase is additive, speed is source time per injected second |
| CSkyFrame | Copied sky simulation state shared by main-view and reflection consumers |
| ►CSkyProfile | Immutable validated atmospheric sky profile, schema eve.sky-profile versions 1 through 6 |
| CImpl | |
| ►CSkyRuntime | Owns independent sky simulation and its prepared atmospheric contributor |
| CImpl | |
| CSkyRuntimeFrame | Copied simulation and evaluated solar lighting used by every view |
| CSkyRuntimeSettings | Independent runtime settings; not a serialized profile or a legacy DayNight override |
| CSkySolarOrbit | Non-astronomical daily solar orbit, matching the reference's manual pitch/yaw mode |
| CSkyTimeline | Owns one independent sky clock, weather transition and integrated cloud travel |
| CSkyWeather | Independent sky weather values; distances are metres and wind is metres/second |
| ►Ndebug | |
| CIRenderTracer | Optional render-pipeline tracer. Graphics / RenderSystem call the rt* helpers; when no tracer is installed they are cheap null checks (Android/iOS keep this unset because EVDevTools is not linked there) |
| CRenderPassScope | RAII pass scope for C++ call sites |
| ►Ndecal | |
| ►CDecal | Runtime decal module — project surface effects (blood, dirt, scorch, dents via normal maps, ...) onto any world geometry |
| CProceduralBakeCache | |
| CDecalInstance | One live decal instance (CPU-side state; GPU draw happens per frame) |
| CDecalManager | CPU-side decal registry: spawn / remove / fade / quotas, and the per-frame drawer that feeds the graphics decal pass |
| CProceduralDecalBake | Owning, renderer-neutral output of one decal bake |
| CProceduralDecalLayer | One independently art-directed layer of a procedural decal recipe |
| CProceduralDecalRecipe | Versioned two-layer authoring recipe analogous to Procedural Decal's Standard graph and material-instance presets |
| ►Ndecal_editing | |
| CDecalDocumentTarget | Stable, serializable authoring document for one projected decal |
| CDecalGizmoPreviewService | Builds projection-box and normal overlays for decal placement tools |
| CDecalPublishingTarget | Candidate-first operation target synchronizing author state and a live decal |
| CDecalRuntimeBinding | Candidate-first binding from one stable decal document to DecalManager |
| CIDecalRuntimeAssetResolver | Resolves every decal texture before a live generation is replaced |
| CIDecalRuntimeSink | Atomic publication boundary for a complete decal candidate |
| ►Ndecision | |
| CCondition | Immutable condition AST node |
| CConditionResult | Explain one condition evaluation in a UI- and log-friendly form |
| CDecision | Script factory for independent decision contexts |
| CDecisionContext | Data-oriented blackboard, FSM, utility and influence-map workspace |
| CDecisionContextHandleTag | Handle domain for module-owned decision contexts |
| CEvaluationContext | Read-only state boundary used by every condition evaluation |
| CScriptConditionDeclaration | Metadata a script policy must declare before it is used by a condition |
| ►Ndefinition | |
| CDefinitionHandle | A generation-qualified reference to one definition incarnation |
| CInstanceIdentity | Canonical identity carried by every typed runtime instance |
| CReloadOutcome | Identity transition emitted by a typed runtime reload operation |
| CRuntimeInstance | Owns one strongly typed runtime state and its definition identity |
| CRuntimeInstanceCore | Type-erased bookkeeping shared by every RuntimeInstance<State> |
| ►Ndefinitions | |
| CDefinition | One immutable view of a registered versioned JSON definition |
| CDefinitionEvent | Registry mutation notification in deterministic sequence order |
| CDefinitionRegistry | Deterministic registry of topic-neutral, versioned JSON definitions |
| CDefinitions | Script module factory for independent definition registries |
| ►Ndefinitions_editing | |
| CDefinitionDocument | UI-neutral versioned definition asset and cross-reference model |
| CDefinitionReferenceField | Stable cross-definition reference exposed to picker and validation hosts |
| CDefinitionRuntimePublisher | Optional bridge publishing a validated definition to DefinitionRegistry |
| CDefinitionSchemaFormTarget | Schema-driven property adapter for one definition document |
| ►Ndemo | |
| CDemo | Optional demo-only helpers (procedural SFX / planet albedo). Built only when EVENGINE_BUILD_DEMO=ON; other games need not link or compile this |
| ►Ndetail | |
| CArtifactIdTag | ArtifactIdTag public API |
| CAssetGuidTag | AssetGuidTag public API |
| CCommandIdTag | CommandIdTag public API |
| CContentIdTag | ContentIdTag public API |
| CDocumentIdTag | DocumentIdTag public API |
| CEffectIdTag | EffectIdTag public API |
| CEventIdTag | EventIdTag public API |
| CEventLogValidator | Incremental validator for the retained event log of a registry image |
| CEventSequenceTag | EventSequenceTag public API |
| CFrameIndexTag | FrameIndexTag public API |
| CGenerationTag | GenerationTag public API |
| CHandleCoordinates | Tag-free slot coordinates behind every RuntimeHandle<Tag> |
| CId128 | Id128 public API |
| COperationIdTag | OperationIdTag public API |
| CPersistentIdTag | PersistentIdTag public API |
| CResourceReceiptIdTag | ResourceReceiptIdTag public API |
| CResourceReservationIdTag | ResourceReservationIdTag public API |
| ►CResultObservation | Debug-only observation token shared by Result<T> specializations |
| CInactiveTag | Start an inactive token used while a Result move is constructed |
| CRevisionTag | RevisionTag public API |
| CSceneObjectIdTag | SceneObjectIdTag public API |
| CSchemaVersionTag | SchemaVersionTag public API |
| CSimulationTickTag | SimulationTickTag public API |
| CStrongUint64 | StrongUint64 public API |
| CTransactionIdTag | TransactionIdTag public API |
| CUuidIdState | Tag-free state of a compatibility-aware UUID identity adapter |
| ►Ndev | |
| ►Nlsp | |
| CFoldingRange | One foldable region (0-based inclusive end line) |
| CFormatOptions | Editor formatting preferences from LSP FormattingOptions |
| CLocation | Location public API |
| CPosition | Position public API |
| CRange | Range public API |
| CSemanticToken | One identifier classified for editor semantic highlighting |
| CTextEdit | TextEdit public API |
| ►CWorkspaceIndex | Cross-file semantic index for EveScript source modules |
| CImpl | |
| CTarget | |
| CUnit | |
| CAgentAcceptanceCriterion | One explicit acceptance condition for a development objective |
| CAgentDevelopmentEvidence | Immutable evidence recorded against an acceptance condition |
| CAgentDevelopmentResult | Structured result for development-session state transitions |
| CAgentDevelopmentSession | Process-owned state machine and evidence ledger for Agent game development |
| CAiLogEntry | |
| CAiPanel | In-engine AI / MCP session surface for DevTools |
| CBreakpoint | |
| CCallFrame | |
| ►CCallGraph | Runtime call graph + dynamic data-flow tracer with backward slicing |
| ►CEventsView | Chronological view over the live ring window (oldest → newest) |
| Cconst_iterator | |
| CConsoleLine | |
| CConsolePanel | In-engine runtime console / log ring buffer for DevTools |
| CConsoleSlice | One bounded read of the console ring buffer together with its cursors |
| CDataFlowEdge | |
| CDebugAdapter | Minimal Debug Adapter Protocol (DAP) server for VS Code |
| CDebugger | Script + frame debugger: pause/step, breakpoints, watches |
| ►CDevTool | Platform-level script + render debugger / dynamic slicer front-end |
| CProfileEntry | Per-function script profile (line-hook timing) |
| CFrameStatsPanel | Lightweight FPS / frame-time overlay for DevTools (0.6 closeout) |
| CImmortal | Process-immortal singleton holder for DevTools objects |
| CInspectCapture | 一次原子快照的结果：PNG 渲染帧 + 配套几何 JSON。 |
| CInspectView | 场景巡检工具集（MCP 底层数据底座）。 |
| CIPlayHostRuntime | Injected runtime used by Play Host. Tests supply a fake; MCP uses the engine adapter. Implementations must not retain request pointers and must not invoke unknown callbacks. @thread Owner simulation / game-loop thread only |
| ►CLanguageServer | In-process EveScript language service used by eve language-server and by unit tests. Owns a dedicated Runtime so it can compile without a running game. JSON-RPC is optional; typed methods are the canonical API |
| CImpl | |
| CLanguageSignatureHelp | Binding-contract signature shown while typing a call |
| CLanguageSignatureParameter | One parameter in an LSP signature-help result |
| CMcpServer | Embedded Model Context Protocol (MCP) server for AI-assisted game development |
| CPlayReplayGuard | RAII flag so nested Play requests during replay are not recorded |
| CPlayTraceBuffer | Process-owned append buffer for trace=append |
| CReloadSession | One state hot-reload transaction: capture → reload → restore |
| CRenderEvent | |
| ►CRenderFlow | Render-pipeline flow tracer with a Weiser-style backward slice |
| ►CEventsView | Chronological view over the live ring window (oldest → newest) |
| Cconst_iterator | |
| CRenderSliceCriterion | |
| CRenderSliceResult | |
| CRenderVision | Vision-model bridge for rendered-frame review (desktop / devtools only) |
| CScenarioEvent | One serializable event payload recorded from the event queue |
| CScenarioFrame | All events consumed during one game frame |
| CScenarioRecorder | A state-driven bug scenario: baseline snapshot + ordered per-frame inputs |
| CSceneInspect | |
| CSliceCriterion | Criterion for a Weiser-style dynamic backward slice |
| CSliceResult | |
| CSnapshot | Script + native state snapshot for state hot reload |
| CSoftRestartReport | Outcome of a successful soft restart. @ownership Owning value; safe to keep across frames |
| CSoftRestartRequest | Inputs for one soft restart. @thread Game / MCP poll thread only |
| CSourceLoc | Source location in a Squirrel (or synthetic) script |
| CStackFrameInfo | |
| CTraceEvent | One recorded runtime event used by the dynamic slicer |
| CVariableInfo | |
| CWatchEntry | |
| ►Ndialogue | |
| CCommandRequest | Immutable request emitted by a command node |
| CCommandResponse | Structured response to a request emitted by a command node |
| CConversationDiagnostic | Stable diagnostic emitted by dnut compilation, lint, or migration |
| CConversationDocument | Mutable, UI-neutral conversation document for custom editor composition |
| CConversationLocalizationCatalog | CSV-backed translation and voice recording catalog with default-locale resolution |
| CConversationLocalizationEntry | Runtime translation and voice-production row keyed by stable key and locale |
| CConversationSaveMigrations | Explicit save migrations from an old asset version to its current version |
| ►CConversationTextRenderer | Parameter substitution and state-driven character voice modifiers |
| CToneRule | ToneRule public API |
| CDialogue | Visual-novel style dialogue stage. Script: dlg <- eve.Dialogue(); |
| CDialogueAccountBindings | Borrowed account bindings used by one DialogueFlow integration |
| CDialogueControl | Exposes the module's conversation runner through the shared gameplay protocol |
| ►CDialogueFlow | Script-facing registry and runner for compiled .dnut conversations |
| CIntegrationConfig | Borrowed world and cross-domain callbacks used by all conversations in this facade |
| CDialoguePaymentAdapter | Composes Dialogue accounts with StatePatch or Action participants |
| CDialogueStateContext | Dialogue-owned facade for world reads, unified conditions, and mutations |
| CDialogueStateMutationParticipant | Transaction participant that delegates an atomic state mutation |
| CDialogueUX | Presentation state shared by default and custom dialogue UIs |
| CDialogueVoice | Localized voice assets, duration-based advance, and amplitude lip sync |
| CDnutDocument | UI-neutral syntax tree produced by the single dnut parser |
| CDnutSourceSpan | Exact source location in a dnut document |
| CPaymentSpec | Canonical money/reputation cost attached to a dialogue choice or command |
| CStateEvaluationContext | Decision EvaluationContext backed by one dialogue subject |
| ►Ndialogue_editing | |
| CDialogueGraphCompileResult | Validated, runtime-neutral conversation definition compiled from a graph |
| CDialogueGraphDomain | dialogue.conversation domain for line, choice, branch and action flow |
| CDialogueGraphRuntimeBuilder | Optional bridge constructing the dialogue module's editable document |
| ►Ndnut | |
| CDnutBlock | One top-level dialect block in a shared token buffer |
| CDnutCompileOutput | Owning outcome of compiling one .dnut document |
| CDnutDiagnostic | One structured diagnostic anchored to a .dnut source location |
| CDnutToken | One lexed token with its exact source anchor |
| CSequenceAsset | Immutable, parameterized and versioned compiled sequence |
| CSequenceCommandRequest | Immutable request emitted by a generic command node |
| CSequenceCommandResponse | Structured response returned by a generic command handler |
| CSequenceConditionOutcome | Outcome of one authored condition, as seen by the language core |
| CSequenceNode | One immutable step of a compiled sequence |
| CSequenceParameter | One typed invocation parameter declared by authored content |
| CSequenceRoute | One outgoing edge of a sequence node |
| ►CSequenceRuntime | Caller-owned interpreter over a compiled sequence asset |
| CEvent | One observable transition; every field is owned by the event |
| CStepContext | Borrowed execution context handed to one step handler |
| CStepField | One declared payload field of a step type |
| CStepKindDescriptor | Owning authoring/runtime contract for one step type |
| CStepKindRegistry | Canonical step vocabulary owner and runtime handler router |
| CStepOutcome | Structured outcome of one dispatched step |
| ►Ndomain_gizmo_editing | |
| CEditorGizmoPreviewBuilder | Builds collider, attenuation and light-volume overlays from editor documents |
| ►Neconomy | |
| CCollector | 采集者：WorkerTrip 基线的状态机 （选目标→接近→采集→载荷判定→运输→卸货入账）。 |
| CEconomy | 经济模块（eve.Economy）：资源类型注册 + 玩家账本 + 事件 + 采集流水线。 |
| CEconomyControl | Exposes published player resource ledgers through the shared gameplay protocol |
| CEconomyEvent | 一次经济事件（credit / debit / waste）。 |
| ►CEconomyLedger | 单个玩家的资源账本：当前量、上限、收支与浪费统计。 |
| CSnapshot | Owning deterministic copy of all balance and accounting counters |
| CEconomyLedgerResourceAccount | Adapts one caller-owned EconomyLedger to IResourceAccount |
| CEconomySystem | 经济系统门面：按玩家持有账本、转发事件、注册钩子。 |
| CGatherNode | 地图上的资源节点：储量、再生、采集槽位。 |
| CIEconomy | 经济账本的跨模块查询/操作接口（提供方：economy 模块）。 |
| CResourceTypeDef | 资源类型的静态定义（数据驱动配置的最小单元）。 |
| CResourceTypeRegistry | 资源类型注册表：注册 / 查询 / 清理。 |
| ►Nediting | |
| CAuthorityPlan | AuthorityPlan public API |
| CCommandPlan | CommandPlan public API |
| CCommandRequest | CommandRequest public API |
| CContextSnapshot | ContextSnapshot public API |
| CDomainOperation | DomainOperation public API |
| CEditableTargetState | Dirty region and revision shared by every editable document target |
| CEditingCommandDescriptor | Domain-owned metadata for one planned editing command |
| CEditRegion | EditRegion public API |
| CEditVolume | Integer axis-aligned volume invalidated by a 3D edit |
| CExtensionDescriptor | ExtensionDescriptor public API |
| ►CExtensionProviderRegistry | Thread-safe generation-qualified registry for editing extension providers |
| ►CImpl | |
| CEntry | |
| CFocusSnapshot | FocusSnapshot public API |
| CGizmoPrimitive | Renderer-neutral wire primitive for authoring viewport overlays |
| CGizmoSnapshot | Immutable revision-tagged overlay snapshot consumed by any viewport renderer |
| CGraphConnectionDecision | Result of domain-specific connection validation |
| CGraphDocument | Generic mutable graph model with one authoritative revision clock |
| CGraphDocumentData | Immutable graph document value sent to a domain compiler |
| CGraphEdgeRecord | Directed connection between an output and input pin |
| CGraphNodeRecord | Generic graph node independent of its domain |
| CGraphPinRecord | Stable typed pin owned by a graph node |
| CIDomainOperationTarget | Editable-target capability that applies owning domain operations |
| CIDomainOperationTargetStaging | Optional candidate/publish capability for atomic domain operations |
| CIEditableTarget | IEditableTarget public API |
| CIEditAuthority | Final validation and commit boundary for editor mutations |
| CIEditingCommandRegistry | Lower-layer registration boundary implemented by an editor or runtime editing host |
| CIEditingExtensionProvider | IEditingExtensionProvider public API |
| CIEditingSnapshotProvider | Optional capability exposing a deterministic, persistence-safe editing snapshot |
| CIGraphDomainProvider | Domain-owned typed connection policy |
| CIGridTarget | IGridTarget public API |
| CIIntFieldTarget | IIntFieldTarget public API |
| CIIntVolumeTarget | Stable capability for sparse integer volumes |
| CIPropertyProvider | UI-independent property access for an immutable selection snapshot |
| CIScalarFieldTarget | IScalarFieldTarget public API |
| CLocalWorldAuthority | In-process authority for a single editable runtime or document target |
| CNumericMetadata | NumericMetadata public API |
| CObjectRefValue | ObjectRefValue public API |
| CPropertyDescriptor | PropertyDescriptor public API |
| CPropertyDescriptorLookup | PropertyDescriptorLookup public API |
| CPropertyPath | Dotted property path (layout.size) compared and persisted as text |
| CPropertyPathHash | Hash functor for a dotted property path |
| CPropertyReadResult | PropertyReadResult public API |
| CPropertySchema | EVENGINE_API_PLATFORM public API |
| CProviderHandle | ProviderHandle public API |
| CProviderLease | ProviderLease public API |
| CReadOnlyAuthority | Authority that permits discovery and dry-run but rejects commits |
| CSelectionItem | SelectionItem public API |
| CSelectionSnapshot | SelectionSnapshot public API |
| CStrongIdHash | Hash functor for a strong authoring identifier |
| CTargetDescriptor | Stable discovery metadata exposed by every editable target |
| CTaskContext | Cooperative cancellation and progress API passed to worker code |
| CTaskOutcome | Type-erased result produced by a background editor task |
| CTaskService | Single-worker background queue shared by editor domains |
| CTaskSnapshot | Immutable status returned to UI, scripts and automation clients |
| CTransactionReceipt | TransactionReceipt public API |
| CTransactionSpec | TransactionSpec public API |
| CValue | Deterministic owning value tree shared by authoring hosts |
| ►Neditor | |
| CActionPreviewController | Coordinates deterministic timeline transport with a transactional preview host |
| CActionTimelineClipboard | Owning clipboard shared explicitly by one or more action timeline editors |
| CActionTimelineDocumentWorkspace | Multi-document Montage workspace backed by the engine document service |
| CActionTimelineEditor | Timeline editing controller shared by developer and in-game editors |
| CActionTimelinePayloadEditor | Applies typed partial payload changes through the canonical timeline transaction authority |
| CActionTimelinePreviewPlan | Prepared deterministic preview advance that can be validated before presentation side effects |
| CActionTimelineTabSnapshot | Immutable projection of one open Montage document tab |
| CActionTimelineTarget | Authoritative editor target for one action timeline asset |
| CActionTimelineWidget | Interactive timeline adapter shared by developer and in-game editor hosts |
| CAddScalarFieldOperation | Adds weighted strength to targets exposing IScalarFieldTarget |
| CAnimationRootMotionPreviewSource | Samples root motion from the animation module's registered clip for an action URI |
| CArchSpaceItemPlaceTool | Click-to-place furniture tool committing makePlaceItem with catalog id + yaw |
| CArchSpaceOpeningPlaceTool | Click-to-place door/window tool committing makeCreateOpening on the nearest wall |
| CArchSpaceViewportRay | World-space ray produced by an ArchSpace editor viewport |
| CArchSpaceWallDrawTool | Click-drag wall draw tool. Down starts, Move previews, Up commits makeCreateWall |
| CAssetDatabasePhysicsColliderResolver | High-level AssetDB adapter for the storage-neutral physics resolver |
| CAssetDependency | Directed dependency between two stable asset identities |
| CAssetPage | One page of values tied to an asset index generation |
| CAssetPublication | One owning record/dependency unit staged for an atomic index generation |
| CAssetQuery | Deterministic filter used by headless and UI asset queries |
| CAssetRecord | Value snapshot stored by the editor asset index |
| CAutomationOwnedTarget | Target plus optional borrowed-dependency owner returned by an automation factory |
| CAutosaveDraft | Persisted draft metadata used to decide whether recovery should be offered |
| CAutosaveService | Autosave coordinator that never overwrites the formal document URI |
| CBoxBrushKernel | Rotatable square kernel using a non-owning falloff strategy |
| CBoxVolumeBrushKernel | Axis-aligned cubic volume kernel using a non-owning falloff strategy |
| CBrushPoint | One weighted grid coordinate emitted by a brush kernel |
| CBrushSample | Location and size passed to an interchangeable brush kernel |
| CBrushSampleBuffer | Convenience sink for previews, tests and command construction |
| CBuildingEdgeCurveTool | EditorSession tool that turns one curve-handle drag into one authority transaction |
| CBuildingEdgeCurveToolSelection | Immutable selection/configuration consumed by BuildingEdgeCurveTool |
| CBuildingViewportRay | World-space ray produced by a building editor viewport |
| CCircleBrushKernel | Circular weighted kernel using a non-owning falloff strategy |
| CCommandContext | Immutable execution context captured for a synchronous command |
| CCommandDescriptor | Presentation and execution metadata for a registered command |
| CConstantBrushFalloff | EVENGINE_API_ORCHESTRATION public API |
| CConstraintResult | Result of evaluating one replaceable edit constraint |
| CDeveloperPropertyPresenter | Shared presenter logic that exposes developer-oriented property rows |
| CDialogueLipEnvelopePoint | Normalized amplitude point suitable for mouth-shape/lip-sync preview |
| CDialogueSubtitlePreview | Safe-area subtitle layout and voice/readability diagnostics |
| CDialogueSubtitlePreviewService | Renderer-neutral subtitle layout and waveform-derived lip envelope service |
| CDialogueSubtitleRequest | Immutable subtitle preview request for one localized dialogue line |
| CDiskAssetCatalog | Project Content scanner using stable .evmeta GUID sidecars |
| CDiskAssetScanResult | Result of one disk asset sidecar scan/poll |
| CDiskAtomicDocumentStore | Project-rooted JSON document store with sibling-temp atomic replacement |
| CDocumentKey | Stable document identity; paths are deliberately excluded |
| CDocumentRevision | Separate edit, saved and external-store revision clocks |
| CDocumentService | Document coordinator with revision-safe requestSave/executeSave sequencing |
| CDocumentSnapshot | Immutable document metadata snapshot |
| CEditConstraintPipeline | Ordered, non-owning constraint chain with diagnostics |
| CEditor | Editor building blocks — not a shipped 3D/map editor app. Script: editor <- eve.Editor(); |
| ►CEditorAutomationProvider | MCP/DevTools adapter over command discovery and target coordination |
| CObservationSession | |
| CEditorCommandService | Registry and execution gate for UI-, script- and automation-neutral commands |
| CEditorContext | Context supplied by EditorSession to tools |
| CEditorCurveDocument | UI-neutral reversible curve and gradient timeline document |
| CEditorCurveKey | Stable scalar curve key with editable Hermite tangents |
| CEditorCurvePreview | Bounded revision-tagged curve/gradient lookup preview |
| CEditorDiagnosticService | Thread-safe diagnostic channels consumed uniformly by UI, scripts and MCP |
| CEditorDock | Simple editor chrome regions: left / right / top / bottom / center |
| CEditorDryRunReport | Side-effect-free information returned by an editor preflight |
| CEditorEventTimeline | Bounded copied event timeline with stale-page detection and correlation filtering |
| CEditorExtensionRegistry | Loads game extensions and filters their descriptors for each host |
| CEditorFocusService | Shared semantic focus service for docked editor and game HUD surfaces |
| CEditorGradientStop | Stable normalized RGBA gradient stop |
| CEditorInspector | Property sheet descriptors + values (host renders via ui) |
| CEditorKeyEvent | Keyboard input normalized by the editor host |
| CEditorPersistenceAdapter | Maps the same editor transaction output to a document URI or save slot |
| CEditorPersistenceSnapshot | Loaded checkpoint plus the domain operations recorded with it |
| CEditorPointerEvent | Pointer input normalized by an editor viewport adapter |
| ►CEditorPropertyModel | Adapts command-backed editor properties to the shared MVVM contract |
| ►CObserverState | |
| CEntry | |
| CEditorSelectionService | Channelled selection/focus state shared by editor and in-game presentations |
| CEditorSession | Hosts interchangeable editor tools and routes their lifecycle/input |
| ►CEditorTargetCoordinator | Coordinates editable targets, per-target histories and domain commands |
| ►CImpl | |
| CSessionBinding | |
| CTargetEntry | |
| CTargetSummary | Discovery metadata for one registered editable target |
| CEditorTimelineEvent | Immutable normalized runtime event copied into the editor timeline |
| CEditorTimelinePage | Generation-qualified timeline query page |
| CEditorTimelineQuery | Deterministic event filter used by headless and visual presenters |
| CEditorToolbar | Tool strip state for assembling editor chrome with ui |
| ►CEditorTransactionConsumer | Editor consumer of the common transaction participant/coordinator protocol |
| ►CImpl | |
| CHistoryEntry | |
| CPending | |
| CEditorTransactionRecord | Structured result of one editor transaction or compensation |
| CEditorTransactions | Executes, groups, rolls back and replays arbitrary edit commands |
| CEditorValidationService | Registry of composable validation rules owned by extensions |
| CEditorWorkspace | Composition model shared by project-specific developer and runtime editors |
| CEnvironmentAssetBrowser | Queries and validates cubemap/equirectangular assets from the shared AssetDB |
| CEnvironmentAssetCard | One environment-map asset card independent of a concrete browser UI |
| CEnvironmentAssetPage | Generation-qualified environment asset browser page |
| CExtensionPaletteDescriptor | Semantic palette that can place the same tool differently per audience |
| CExtensionRuleDescriptor | Discoverable gameplay validation rule registered by a game extension |
| CExtensionToolDescriptor | Host-neutral metadata for a game-provided editor tool |
| CFieldBrushTool | Generic stroke tool composed from a brush kernel and field operation |
| CGameplayTagPicker | Searchable selection model shared by developer and in-game editors |
| CGameplayTagPickerEntry | Owning row projected for tree/list UI implementations |
| CGizmoManager | Babylon.js-style manager: toggles which transform modes are enabled and routes pick/drag to the owned TransformGizmo (switching mode on best hit) |
| CHostProfile | Upper capability boundary for one editor host |
| CIArchSpaceViewportAdapter | Host-owned conversion boundary between pointer coordinates and the ArchSpace viewport |
| CIAtomicDocumentStore | Compare-and-swap persistence boundary used by DocumentService |
| CIBrushFalloff | Replaceable mapping from normalized distance to brush strength |
| CIBrushKernel | Shape protocol shared by tile, terrain, mask and custom tools |
| CIBrushSampleSink | Receives weighted points without constraining their storage |
| CIBuildingViewportAdapter | Host-owned conversion boundary between pointer coordinates and a 2D/3D viewport |
| CICurveDocumentEditTarget | Stable key/gradient editing capability shared by effects and animation presenters |
| CIEditCommand | Reversible unit accepted by the editor transaction manager |
| CIEditConstraint | Protocol for game and art-style rules applied before command commit. Implementations may inspect or normalize the mutable command without the editor core knowing the rule's concrete meaning |
| CIEditorAutomationTargetFactory | Multi-provider extension point for domain-specific automation target creation |
| CIEditorExtensionRegistry | Scoped registration surface exposed to game modules |
| CIEditorInspector | UI-independent property editor used by tools to expose settings |
| CIEditorOverlay | Sink implemented by a 2D or 3D viewport to render tool feedback |
| CIEditorSimulationBackend | Cloneable backend boundary for physics/crowd/fluid editor simulation previews |
| CIEditorTool | Protocol implemented by every editor tool |
| CIEditorTransactionBackend | Transaction boundary consumed by editor property and other UI models |
| CIFieldBrushOperation | Replaceable operation that converts brush samples into a command |
| CIGameEditorExtension | Entry point implemented by a gameplay module to inject editor behavior |
| CIMaterialPreviewRenderer | Host boundary that owns creation and teardown of an isolated preview scene |
| CImportCoordinator | Small coordinator that validates importer output before atomic index publication |
| CImportProduct | Validated importer output staged before publishing to AssetDB |
| CImportTicket | Generation-qualified import request used to reject stale worker products |
| CIntFieldChange | IntFieldChange public API |
| CIntFieldEditCommand | Reversible edits to any target exposing IIntFieldTarget |
| CIntVolumeEditCommand | Reversible integer-volume command shared by voxel and custom volume targets |
| CISurfaceFluidPreviewRenderer | Narrow host boundary for drawing a validated fluid preview snapshot |
| CIUiSkinAssetResolver | Asset metadata boundary used by renderer-neutral UI preview planning |
| CIUiSkinPlanRenderer | Narrow presentation boundary consuming a renderer-neutral UI skin plan |
| CIVegetationConversionPreparer | Worker boundary used to prepare a complete vegetation package candidate |
| CIVegetationConversionPublisher | Atomic host publication boundary for one prepared vegetation package |
| CIVolumeBrushKernel | Shape protocol for sparse volume painting |
| CLinearBrushFalloff | EVENGINE_API_ORCHESTRATION public API |
| CLocalTransactionBackend | Local transaction coordinator backed by an injected edit authority |
| CMaterialPreviewRenderRequest | Immutable request passed to a renderer-owned isolated preview scene |
| CMaterialPreviewRenderResult | Renderer output referenced by a stable artifact rather than GPU pointers |
| CMaterialPreviewService | Revision-safe material preview request and publication service |
| CMaterialPreviewSettings | Camera, mesh and environment settings for an isolated material preview |
| CMaterialStudioController | UI-neutral controller for coalesced material edits and revision-safe live previews |
| CMaterialStudioState | Observable state for a host-rendered real-time material studio |
| CMemoryAssetDatabase | Thread-neutral in-memory asset index used by editor hosts and tests |
| CMemoryAtomicDocumentStore | Deterministic in-memory CAS store suitable for tests and transient tools |
| CNativeVegetationConversionPreparer | Built-in preparer backed by the canonical TVE batch transaction |
| COffscreenMaterialPreviewRenderer | Material renderer adapter backed by the shared bound offscreen Canvas service |
| COverlayPoint | A point in the coordinate space chosen by an editor viewport adapter |
| COverlayStyle | Renderer-independent appearance for an editor overlay primitive |
| CPaintIntFieldOperation | Paints a fixed integer into targets exposing IIntFieldTarget |
| CPaintIntVolumeOperation | Paints one integer value into targets exposing IIntVolumeTarget |
| CPluginPermissionGrant | Explicit project-owned permission decision for one plugin capability scope |
| CPluginPermissionTarget | Revisioned plugin permission policy with reversible, auditable grants |
| CPrefabAssetSnapshot | Runtime-neutral prefab authoring snapshot |
| CPrefabDependencyReport | Nested-prefab dependency diagnostics tied to the inspected root revision |
| CPrefabInstancePlan | Stable identity mapping returned with an instantiated prefab plan |
| CPrefabObjectRecord | One stable scene object stored relative to a prefab root |
| CPrefabOverrideRecord | One inspector/hierarchy badge describing an instance override |
| CProjectSettingDescriptor | Project-setting descriptor with deployment and secrecy policy |
| CProjectSettingsSchema | Versioned settings schema shared by project and importer documents |
| CProjectSettingsTarget | Schema-driven, reversible settings target with secret-reference enforcement |
| CPropertyEditIntent | Command intent emitted by a presenter instead of calling a setter |
| CPropertyPresentation | Immutable presentation model consumed by developer or game UI |
| CPropertyPresentationRow | Read-only row produced for a concrete property UI adapter |
| CReflectionProbeVisualizer | Renderer-independent wire-box and status description for a reflection probe |
| CRuntimeEditorManifest | Explicit publish allow-list for a player-facing editor build |
| CRuntimeEditorPackage | Resolved editor package embedded into a game build |
| CRuntimeEditorPublisher | Validates an explicit manifest and resolves its runtime dependency closure |
| CRuntimePropertyPresenter | Shared presenter logic that exposes only runtime-safe property rows |
| CSaveTicket | Immutable save request capturing one exact edit revision |
| CScalarFieldChange | ScalarFieldChange public API |
| CScalarFieldEditCommand | Reversible edits to any target exposing IScalarFieldTarget |
| CScenePrefabService | Backend-neutral prefab capture, instantiate and override planning |
| CScriptBind | Editor facade binder: common script::BindContext plus history/owned-create helpers |
| ►CScriptEditorTool | IEditorTool adapter whose lifecycle and input callbacks are Squirrel closures |
| CImpl | |
| CSimulationBakeResult | Non-destructive baked preview trajectory and diagnostics |
| CSimulationObjectSample | Stable transform sample captured from one simulation object |
| CSimulationPreviewController | Pause/single-step/bake controller shared by simulation editor modules |
| CSimulationPreviewFrame | One deterministic editor-preview simulation frame |
| CSmoothBrushFalloff | SmoothBrushFalloff public API |
| CSphereVolumeBrushKernel | Spherical volume kernel using a non-owning falloff strategy |
| CStoredDocument | Value snapshot returned by an atomic document store |
| CStylizeOffscreenPreviewService | Host presentation adapter for isolated stylize preview readback |
| CSurfaceFluidOffscreenPreviewService | Builds and rasterizes surface-fluid scrub frames through shared Canvas readback |
| CSurfaceFluidPreviewDroplet | Renderer-neutral world-space droplet cap produced by one scrub replay |
| CSurfaceFluidPreviewRequest | Complete deterministic input needed to replay a surface-fluid scrub |
| CSurfaceFluidPreviewSeed | One stable droplet seed in material-space triangle coordinates |
| CSurfaceFluidPreviewService | Rebuilds an isolated surface simulation for deterministic forward/backward scrub |
| CSurfaceFluidPreviewSnapshot | Revision-bound result containing droplet geometry and per-vertex wetness |
| CTimelineHit | Result of widget hit testing |
| CTimelineItemGeometry | Owning geometry projected for one timeline item |
| CTimelineRulerTick | One deterministic ruler tick projected into host coordinates |
| CTimelineSelectionRange | Exact outer time bounds of the current owning timeline selection |
| CTimelineWidgetCommandDescriptor | One host-renderable command entry |
| CTimelineWidgetLayout | Complete renderer-neutral layout for one widget frame |
| CToolDescriptor | UI-facing metadata supplied by a tool implementation |
| CToolResponse | Result returned by a tool after processing input |
| CTransformGizmo | 3D transform gizmo (Three.js TransformControls + ImGuizmo style). Owns TRS + optional local bounds; interaction via world-space rays. Host renders using getPart* descriptors — no GPU dependency |
| CUiOffscreenPreviewRenderer | Concrete UI box-model preview renderer using the shared offscreen Canvas |
| CUiSkinDrawCommand | One deterministic text or image command, including effective clipping |
| CUiSkinDrawPlan | Revision-bound content plan suitable for graphics or UI-host presenters |
| CUiSkinPreviewPlanner | Builds deterministic text/texture commands without touching runtime graphics |
| CUiTextureMetadata | Dimensions known for an editor-resolved UI texture |
| CValidationRequest | Context supplied to project- and document-level validation rules |
| CVegetationConverterController | UI-neutral TVE converter controller with revision-safe prepare and publish phases. @ownership The preparer and publisher are borrowed and must outlive this controller. @thread Owner thread only. Calls are synchronous and no controller lock is held across either boundary. @reentrancy Preparer and publisher implementations must not call this controller recursively |
| CVegetationConverterState | Host-visible state of the TVE conversion tool |
| CVolumeBrushPoint | One weighted integer coordinate emitted by a three-dimensional kernel |
| CVolumeBrushTool | Generic 3D stroke tool composed from a volume kernel and paint operation |
| CWorkspacePanelDescriptor | UI-neutral description of one composable editor panel |
| ►Neffects | |
| CEffectContainer | Owns active effect instances and their deterministic lifecycle events |
| CEffectContainerHandleTag | Owner tag for non-ECS effect-container handles |
| CEffectDefinition | Immutable-by-convention template used to create effect instances |
| CEffectDefinitionRuntime | Binds a typed effect runtime to a generation-qualified definition |
| CEffectEvent | Deterministically sequenced effect lifecycle event |
| CEffectExecutor | Executes lifecycle time progression for an EffectContainer |
| CEffectHandle | Generation-qualified local reference to a canonical effect instance |
| CEffectInstance | One owned runtime effect fact |
| CEffectPayload | Deterministic JSON-compatible payload carried by a definition or instance |
| CEffectPeriodicTick | One periodic trigger handed to a domain executor for settlement |
| CEffectPolicy | Independent policy dimensions used when applying an effect definition |
| CEffectRuntimeState | Typed mutable lifecycle values for one effect instance |
| CEffects | Script module factory for generic effect containers |
| CEffectUpdateSummary | Summary returned by the lifecycle executor after one simulation step |
| ►Nemergence | |
| CActivation | One scheduled activation produced by drain() |
| CEmergence | Script-facing module that owns RuleEngine instances |
| CEmergenceAction | One deferred side-effect descriptor; domains interpret kind |
| CFactStore | Mutable fact bag that doubles as a read-only Condition evaluation context |
| CRuleDefinition | One immutable rule definition owned by the catalogue |
| CRuleEngine | Indexed, deferred rule evaluator for tens of thousands of conditions |
| CRuleEngineHandleTag | Handle domain for module-owned rule engines |
| CWatchIndex | Dense, sorted multi-map used to wake O(watchers) rules on a fact change |
| ►Nfilesystem | |
| ►Ncppfs | |
| CFile | File which is created when a user drags and drops an actual file onto the eve game. Uses C++ stdio & filesystem. Filenames are system-dependent full paths |
| ►Nphysfs | |
| CFile | File public API |
| CFilesystem | PhysFS 文件系统后端实现（挂载/解挂、读写、热重载）。 |
| CFile | A File interface, providing generic means of reading from and writing to files |
| CFileData | Data buffer paired with a filename (used for type identification) |
| ►CFilesystem | EVENGINE_API_FOUNDATION public API |
| CInfo | Info public API |
| ►CFileWatch | OS directory watch with a main-thread event queue. Desktop/mobile: backed by Poco::DirectoryWatcher (see FileWatch.cpp). WebGPU (Emscripten): the browser VFS has no native file watching, so this is a no-op stub — add()/remove() return false, poll() returns false |
| CDirWatch | |
| CEvent | Event public API |
| CHotReload | Path→reload dispatcher for soft hot reload. Driven from load.nut via pollWatch → tryReload; also used by watchTree |
| CResourceReader | Reads project resources through the filesystem capability |
| ►Nfluids | GLSL compute kernels for the GPU surface-flow solver |
| CAirborneDroplet | Persistent world-space droplet after it has detached from a surface |
| CDetachedDroplet | Droplet converted from a surface-bound state to a free world-space state |
| CFluidParams | Tuning knobs of one fluid simulation |
| CFluidParticle | One simulated particle (CPU reference layout) |
| CFluidRendererSettings | Complete owning mirror of Fluid3DRendererSettings with package defaults |
| CFluids | Fluids module — factory + script binding |
| CFluidSimulation | CPU reference surface-flow solver |
| CFluidSimulationAdapter | Adapter exposing the existing CPU FluidSimulation through the contract |
| CFluidSimulator | GPU-backed surface fluid simulator (falls back to the CPU solver) |
| CFluidSurfaceBinding | Dynamic triangle surface used to bind films and droplets to deforming meshes |
| CFluidSurfaceConstraintAdapter | Adapter exposing existing FluidSurfaceBinding operations as checked results |
| CFluidSurfaceParams | Camera + reconstruction tuning for the SSF pipeline |
| CFluidSurfaceRenderer | Buffer-level screen-space fluid renderer |
| CIScreenSpaceSurfaceReconstruction | Presentation contract for screen-space surface reconstruction |
| CISurfaceConstraint | Backend-neutral contract for mesh-surface binding and traversal |
| CISurfaceFluidSimulation | Backend-neutral contract for advancing a surface-fluid solver |
| CMeshSdf | Uniform signed-distance voxel field over a box |
| CMeshSdfSample | One trilinear SDF sample and its local-space analytic gradient |
| CScreenSpaceSurfaceReconstructionAdapter | Minimal SSF adapter over the existing CPU/GPU FluidSurfaceRenderer |
| CSimGrid | Uniform grid used for neighbor queries |
| CSurfaceDroplet | One droplet addressed in material space on a dynamic triangle surface |
| CSurfaceDropletParams | Material and integration parameters for surface-bound droplets |
| CSurfaceDropletRenderInstance | World-space oriented cap instance consumed by droplet instancing shaders |
| CSurfaceDropletSimulation | CPU reference solver for droplets moving over static, rigid or deforming surfaces |
| CSurfaceFluidRenderData | Builds renderer-independent droplet instances and wet PBR parameters |
| CSurfaceFluidRenderParams | Tuning for converting simulated droplets into render instances |
| CSurfaceFluidSceneRenderer | Draws surface-droplet cap instances through the engine 3D backend |
| CSurfaceLocation | Stable material-space address of a point on a triangle surface |
| CSurfaceSample | Evaluated world-space frame and motion at a surface location |
| CSurfaceWalkResult | Result of walking a material point across triangle adjacency |
| CSurfaceWetnessField | Lightweight material-space wet-film field stored at mesh vertices |
| CSurfaceWetnessParams | Parameters controlling persistent wet-film traces on a triangle surface |
| CVolumeFluid | CPU position-based free-volume fluid with a bounded spatial grid. @ownership Owns all particle state; no external objects or callbacks are retained. @thread All methods are simulation-thread affine; concurrent access is forbidden. @reentrancy No callbacks are invoked. Renderers consume copied particle positions |
| CVolumeFluidAttachment | Owned local anchor for a contact-frozen particle; indices refer to its snapshot particle array |
| CVolumeFluidAttachmentReaction | Opposite impulse produced by a prescribed solid-particle attachment constraint |
| CVolumeFluidCollider | Owned obstacle sample; the caller updates moving obstacles before stepping |
| CVolumeFluidColorKey | One strictly ordered [0,1] coordinate and linear RGBA gradient color |
| CVolumeFluidContact | Owned contact event; opposite impulse can be applied to the caller's rigid body |
| CVolumeFluidContactEvent | Owning deduplicated actor/collider contact lifecycle event |
| CVolumeFluidContactTracker | Explicit bounded contact lifecycle tracker; owns no solver reference |
| ►CVolumeFluidCoupling | Process-local generation-checked bridge between fluid samples and rigid bodies. @ownership Owns local collider descriptions and typed physics links, never world/body/solver pointers. @thread Simulation-thread affine; no callbacks, concurrent mutation or reentrancy |
| ►CImpl | |
| CBinding | |
| CVolumeFluidDiffuse | Bounded, one-way fluid-advected secondary particle pool. @ownership Owns particles and capacity; no fluid/world pointers are retained. @thread Simulation-thread only, including snapshots; no concurrent calls. @reentrancy Invokes no callbacks. Advance borrows its fluid only for that call |
| CVolumeFluidDiffuseParticle | Owned secondary particle; it contributes no mass or pressure to the liquid solver |
| CVolumeFluidDiffuseSnapshot | Strict version-1 diffuse pool state; unknown fields and versions are rejected |
| CVolumeFluidDistanceHit | Owning signed surface-distance result for a native query shape |
| CVolumeFluidDistributionPoint | Owned precomputed local emission sample, including shape-specific color |
| CVolumeFluidEmission | Value-owned emission description; +Z is mapped to direction |
| CVolumeFluidEmitter | Bounded runtime stream controller with explicit snapshot/restore |
| CVolumeFluidEmitterBlueprint3D | Owning Fluid3DEmitterBlueprint values used to prepare a native 3D emitter |
| CVolumeFluidEmitterBlueprintApplication3D | Fully owned native setup prepared from one Fluid3D-emitter blueprint |
| CVolumeFluidEmitterBlueprintMetrics | Exact 3D metrics derived by Fluid3DEmitterBlueprintBase from resolution and density |
| CVolumeFluidEmitterCheckpoint | Version-1 owning atomic checkpoint for a solver, emission description and controller |
| CVolumeFluidEmitterSnapshot | Version-1 owning state for rate (kind 0) or jet (kind 1) controllers |
| CVolumeFluidFieldSample | Owned liquid/gas field sample for diffuse-particle emission and advection |
| CVolumeFluidFoam | Generates secondary particles at high-curl, low-density fluid source positions. @ownership Owns settings, credit and RNG only; neither source nor pool is retained. @thread Simulation-thread affine, including snapshot/restore; no concurrent calls. @reentrancy No callbacks or script invocation. No global time or RNG access |
| CVolumeFluidFoamSettings | Foam source thresholds in the native sampled field, plus bounded emission settings |
| CVolumeFluidFoamSnapshot | Owning strict version-1 foam controller state; checkpoint the diffuse pool separately |
| CVolumeFluidGridCell | Owning occupied-cell sample for Fluid3DParticleGridDebugger-style visualization |
| CVolumeFluidHeightFieldCollider | Owned regular-grid terrain collider matching Fluid3D height-field sample layout |
| CVolumeFluidJetEmitter | Spacing-driven planar/distribution jet controller with independent, owned stream phase |
| CVolumeFluidMassProperties | Owning mass summary for one Fluid3D-compatible actor group |
| CVolumeFluidMaterial | Per-particle material, copied at emission; densities enable multiphase buoyancy |
| CVolumeFluidNozzlePose | Owning world-space nozzle pose; rotation is a unit quaternion in XYZW order |
| CVolumeFluidParticle | Owning particle value with world position and velocity in SI units |
| CVolumeFluidParticleEvent | Owning particle lifecycle event captured before the dense pool changes again |
| CVolumeFluidParticleEventBatch | Owning result of one explicit particle lifecycle-event drain |
| CVolumeFluidParticleFrame | Owning local-axis sample for DebugParticleFrames-style visualization |
| CVolumeFluidParticleInstance | One owning mesh-instance transform/color row for Fluid3DInstancedParticleRenderer-style presentation |
| CVolumeFluidQueryHit | Owning result from one entry in a mixed query batch |
| CVolumeFluidQueryShape | Owning transient query description compatible with Fluid3D QueryShape semantics |
| CVolumeFluidRayHit | Owning ray hit against one native oriented-ellipsoid volume-fluid particle |
| CVolumeFluidSdfCollider | Owned sampled mesh/SDF collider with a uniform world transform |
| CVolumeFluidSdfPose | Transient transform update for one owned SDF collider, identified by stable label |
| CVolumeFluidSdfSlice | Owning normalized SDF slice plus its world-space sample lattice |
| CVolumeFluidSettings | Meter-space (+Y up) volume-fluid material and solver policy |
| CVolumeFluidShadowCaster | One-draw particle shadow caster matching Fluid3D ShadowmapExposer behavior. @ownership Borrows Graphics for its lifetime and owns one Graphics-managed dynamic mesh. @thread Construction, update and destruction are render-thread affine. @reentrancy Invokes no script callbacks; destruction must occur outside shadow traversal |
| CVolumeFluidSimplex | A point, edge or triangle over snapshot-local particle indices |
| CVolumeFluidSimplexHit | Owning Fluid3D-compatible nearest result for one simplex and query pair |
| CVolumeFluidSnapshot | Canonical version-20 owning state; older codecs migrate collider, attachment, stitch, filter, group, material, shape, topology, height-field, trigger and collision-material fields |
| CVolumeFluidStitch | One Fluid3DStitcher-compatible zero-distance particle-pair constraint |
| CVolumeFluidThermalRule | One-step contact transfer into user channels x/y; negative rate heats, positive cools |
| CVolumeFluidViscosityColorKey | Transient linear RGBA gradient key at an absolute material viscosity |
| CVolumeFluidWindZone | Owning description of one transient ambient or spherical wind zone |
| CVolumeGranularEmitterBlueprint3D | Owning Fluid3DGranularEmitterBlueprint values used to prepare a native 3D emitter |
| CWetSurfaceMaterialParams | Material mapping from simulated wetness to a PBR surface response |
| CWetSurfaceMaterialSample | Evaluated material values suitable for a wet-surface shader |
| ►Nfluids_editing | |
| CFluidSimulationPreview | Cost estimate used before allocating or running a fluid preview |
| CFluidSimulationRuntimeApplier | Optional bridge applying authored tuning to a live FluidSimulation |
| CFluidSimulationSettings | Serializable parameters matching the CPU/GPU surface fluid solver |
| CFluidSimulationTarget | Reversible property document for fluid simulation authoring |
| CSurfaceFluidRuntimeApplier | Optional bridge copying a validated document into live fluid components |
| CSurfaceFluidSettings | Renderer-neutral droplet motion, wet-film and wet-material authoring values |
| CSurfaceFluidTarget | Reversible document for surface droplets, wet traces and material response |
| CVolumeFluidAuthoringPreview | Bounded preview allocation/work estimate before constructing a solver |
| CVolumeFluidAuthoringSettings | Serializable authoring parameters for the bounded volume-fluid solver |
| CVolumeFluidRuntimeApplier | Atomic bridge from a validated authoring document to a live solver |
| CVolumeFluidTarget | Reversible schema-driven document for native volume-fluid solver settings. @ownership Owns only authoring values; it never owns or retains a runtime solver. @thread Editor-thread affine. @reentrancy Does not invoke callbacks |
| ►Nfluids_editor | |
| CFluidsAutomationTargetFactory | Creates schema-driven fluid documents for editor automation. @ownership Returned targets own their authoring state; the factory retains nothing. @thread Editor/composition-thread affine. @reentrancy Does not invoke callbacks or retain request values |
| CFluidsEditorModule | Composition adapter that publishes the fluid automation-target factory. @ownership Owns the registered factory and removes it before destruction. @thread Owner/composition-thread affine. @reentrancy Do not construct or destroy while factory listeners are being enumerated |
| ►Nfont | |
| CFont | Resource module for decoding TrueType / OpenType fonts via FreeType. Produces FontData (CPU metrics + glyph raster); GPU upload/draw is graphics' |
| CFontData | CPU-side decoded font face (FreeType FT_Face + owned font bytes). Does not upload to GPU — rasterize glyphs to ImageData for graphics::Texture |
| ►Ngame_event | |
| CCausationRef | Tagged direct causation reference to an event or command |
| CCorrelationId | Strong business-workflow correlation identity |
| CEventConsumer | Independent sequence cursor used to consume an GameEventLog in batches |
| CGameEvent | Envelope metadata shared by event domains |
| CGameEventLog | Deterministic in-memory stream of topic-neutral event envelopes |
| CGameEventModule | Script module factory for generic GameEventLog objects |
| CTypedEventEnvelope | Strongly typed event value used before serialization into a stream |
| ►Ngpgpu | Fluids module — interactive surface fluid simulation |
| CComputeShader | Backend-agnostic compute program. Bind storage buffers then dispatch via Gpgpu::dispatch. Push constants: float[32] (same size as graphics::Shader) |
| CEcsGpuWorkspace | Reusable typed CPU staging for a GPU ECS component stream. Ownership stays with the caller; one workspace must not be used concurrently |
| CGpgpu | GPGPU module — compute shaders + storage buffers via the active Graphics backend. Uses the graphics queue when no dedicated compute family exists (Apple/MoltenVK) |
| CGpuBuffer | Backend-agnostic GPU buffer for compute (storage) or CPU staging transfers. Squirrel-owned; derived class destroys GPU resources in destructor |
| ►CSequence | EVENGINE_API_WORLD public API |
| CImpl | |
| CShaderSystem | EVENGINE_API_WORLD public API |
| CVulkanComputeShader | Vulkan 计算着色器（SPIR-V pipeline + descriptor 管理）。 |
| CVulkanGpuBuffer | Vulkan 计算缓冲区实现（storage/vertex buffer + device memory）。 |
| CVulkanSequence | VulkanSequence public API |
| CWebGpuComputeShader | Compute program for the WebGPU backend. Accepts WGSL source; GLSL/SPIR-V input is rejected (browsers only accept WGSL at runtime) |
| CWebGpuGpuBuffer | Storage / staging buffer for the WebGPU backend |
| ►CWebGpuSequence | |
| CDispatch | |
| CDownload | |
| CUpload | |
| ►Ngpuagents | |
| ►Ndetail | |
| CNeighborAccum | NeighborAccum public API |
| CAgentInstanceRenderer | Packs standardized AgentState into instance transforms for draw submission |
| CAgentState | Standardized per-agent simulation output shared by all effect kinds |
| CBirdProfile | Bird flock flight-dynamics parameters |
| CBirdSolver | Bird flock solver with lift / drag / stall / bank (CPU reference) |
| CDynamicObstacleSource | Dynamic spherical obstacle source (e.g. moving prop / wake body) |
| CEffectBackend | Binds an EffectProfile to a GpuAgentSimulation and optional renderer |
| CEffectProfile | Type-erased profile bundle owned by an EffectBackend |
| CEffectProfileBase | Shared capacity / timing / collision envelope for every effect |
| CEnvironmentMarker | Point attractor / repulsor / danger marker in world space |
| CEnvironmentSnapshot | Read-only environment semantics prepared by GpuAgentWorld each tick |
| CFishProfile | 3D Boids fish school parameters |
| CFishSolver | 3D Boids fish school solver (CPU reference) |
| CGpuAgents | GPU Agents module — extensible fixed-step agent FX simulation |
| CGpuAgentSimulation | Fixed-step, double-buffered agent simulation owner |
| CGpuAgentWorld | World-level registry for GPU agent simulations and environment semantics |
| CIAgentSolver | Solver kernel contract: consume read buffer, write next state |
| CLifeFieldMaterialBinding | Packs SurfaceField channels into Graphics-uploadable RGBA8 textures |
| CLifeFieldMaterialUniforms | Uniform block exposed to materials consuming Life Network surfaces |
| CLifeNetworkProfile | Life Network 2D surface-trail parameters |
| CLifeNetworkSolver | Life Network 2D surface-trail solver (CPU reference) |
| CObstacleField | Unified static + dynamic obstacle distance field |
| CObstacleSample | One SDF sample with outward gradient |
| CPetalProfile | Passive petal rigid-body aerodynamic parameters |
| CPetalSolver | Passive petal rigid-body aerodynamic solver (CPU reference) |
| CSurfaceCapture | Orthographic surface capture that rebuilds height + normals on a SurfaceField |
| CSurfaceField | 2.5D surface + life-field textures for Life Network |
| ►Ngpuagents_editing | |
| CGpuAgentsDocumentTarget | Reversible document for GPU Agents effect authoring |
| CGpuAgentsRuntimeApplier | Optional bridge projecting a validated document into live World/Backend. @ownership Borrowed world/backend; does not take ownership |
| CGpuAgentsSettings | Authoring values for one GPU Agents effect document |
| ►Ngpuagents_editor | |
| CGpuAgentsAutomationTargetFactory | Creates schema-driven GPU Agents documents for editor automation. @ownership Returned targets own their authoring state; the factory retains nothing. @thread Editor/composition-thread affine. @reentrancy Does not invoke callbacks or retain request values |
| CGpuAgentsEditorModule | Composition adapter that publishes the GPU Agents automation-target factory. @ownership Owns the registered factory and removes it before destruction. @thread Owner/composition-thread affine. @reentrancy Do not construct or destroy while factory listeners are being enumerated |
| CGpuAgentsPreviewAgent | One agent sample in a preview snapshot |
| CGpuAgentsPreviewRequest | Deterministic scrub request for editor preview |
| CGpuAgentsPreviewService | Rebuilds an isolated GPU Agents simulation for deterministic scrub preview. @ownership Service is value-owned; does not retain document/world pointers across calls |
| CGpuAgentsPreviewSnapshot | Revision-bound preview snapshot with optional life-field energy |
| ►Ngraphics | 卡牌游戏 UI 工具模块：工厂 + 脚本绑定入口。 功能参考 ycarowr/UiCard：扇形手牌布局、抽牌/洗牌、悬浮放大、拖拽到落牌区、 敌方手牌（背面/偷看）、费用不足置灰，以及可实时调节的布局参数。 数据模型与渲染/交互逻辑见 CardTypes.h。 |
| ►Ndetail | |
| CPbrUniformBuildInputs | Backend-neutral state needed to build one immutable PBR uniform snapshot |
| CPbrUniformGpu | Canonical std140 payload consumed by both generated PBR shader stages |
| CPbrUvInfoGpu | Std140 texture-coordinate metadata shared by Vulkan and WebGPU PBR shaders |
| CSkyAtmosphereLuts | Internal owning RGBA32F table candidates, never partially published |
| ►Ndisplay | |
| CSupport | Support public API |
| ►Nfog | |
| CAnalyticalVolLight | Analytic volumetric light: ray ∩ capped frustum, depth-clipped short integral |
| CAnalyticBeam | Analytic beam volume: capped cone frustum or pyramidal spot |
| ►CBeerLightCache | Cached light-path transmittance used by Fast / Enhanced quality tiers |
| CLightKey | LightKey public API |
| CContinuousArt | Post-physics stylization layer |
| CContinuousArtOutput | Stylized fog presentation derived from a physical FogRayResult |
| CContinuousArtParams | Continuous-art stylization that never mutates density or optics |
| CDustParticle | Deterministic dust mote spawned inside an analytic volume |
| CFogCflReport | CFL stability snapshot for the MAC fluid solver |
| CFogDensityField | World-space density bands, curl assist velocity, and lighting helpers |
| CFogFroxelBridge | Maps world-space density into a camera froxel volume and integrates it |
| CFogInteractor | Analytic solid proxies that carve fog and inject wake into the MAC field |
| CFogProfile | Unit-density optical profile for participating media |
| CFogQualityBudget | Resource / sample budget derived from a quality preset |
| CFogRayInterval | Interval along a ray where media is present (t in world units) |
| CFogRayMarch | World-space fog ray marcher with Beer–Lambert extinction and HG phase |
| CFogRayResult | Optical result of integrating one view ray through fog |
| CFogSolidProxy | One analytic solid that carves / wakes the fog domain |
| CFogSystem | Orchestrates density, MAC transport, optics, froxel mapping, and art |
| CFogVolumeBound | Analytic volume used to bound a camera ray before sampling |
| CFogWorldBounds | Axis-aligned world bounds for a fog simulation domain |
| CMacFluidGrid | MAC (Marker-And-Cell) staggered-grid Eulerian fog fluid |
| CProceduralDust | Procedural dust that does not use persistent particle buffers or screen trails |
| CRealtimeFog | Optional graphics satellite for realtime fog (MAC + raymarch + froxel + analytic lights) |
| CSceneWind | World-space wind provider for MAC fog transport |
| ►Ngrass | T3ssel8r-style stylized grass |
| CBillboardMesh | BillboardMesh public API |
| CGrassFoliageSettings | Pcg-style static foliage surface controls packed into the grass shader profile. Values are copied during upload; colors are linear RGB |
| CPackedAtlasInfo | Layout of a packed 2x2-per-variant sway atlas (4 grass + 2 leaf typical) |
| CPoint | Point public API |
| CSampleParams | SampleParams public API |
| CTerrainDetailOverwriteSettings | Runtime terrain-detail overrides kept distinct from foliage material settings |
| ►Nhair | Procedural hair/fur card meshes + material/LOD helpers (no strand simulation) |
| CCardMeshData | CPU-side interleaved mesh arrays for upload via Graphics::newMeshFromArrays |
| CCardRoot | One root sample expanded into a card |
| CClusterGrid | Uniform grid over strand roots for CPU frustum culling |
| CGroomAsset | Shared CPU groom container (UE UGroomAsset analogue) |
| CGroomBinding | Root-to-skin binding table (UE UGroomBindingAsset analogue, CPU-only) |
| CGroomGroup | One groom group (UE hair group analogue: bangs / scalp / beard …). @ownership Owned by GroomAsset |
| CGroomInstance | Runtime groom drawable (UE UGroomComponent analogue) |
| CGroomLod | One LOD entry for a groom group |
| CGuideInfluence | One guide contributing to a render strand |
| CGuideSimParams | Parameters for CPU guide-strand dynamics (UE groom sim lite analogue) |
| CGuideSimulator | Lightweight Verlet + XPBD simulator for guide curves only |
| CHairCluster | One spatial cluster of strand curves (UE cluster-culling analogue). @ownership Owned by ClusterGrid |
| CProceduralParams | Parameters for growing strands on a triangle mesh (scalp / body) |
| CRibbonMesh | Triangle-list ribbon mesh expanded from strand curves |
| CRibbonParams | RibbonParams public API |
| CRootAttach | One strand root projected onto a skin triangle (UE binding entry analogue). @ownership Owned by GroomBinding |
| CSkinTriMesh | Borrowed triangle mesh used as a scalp / skin bind target |
| CStrandCurve | One strand as a contiguous point range. @ownership Value type owned by StrandsDatas |
| CStrandGuideWeights | Up to kMaxInfluences guides influencing one render strand. @ownership Owned by the weights table returned from buildGuideWeights |
| CStrandPoint | One control point on a hair curve (UE FHairStrandsDatas point analogue). @ownership Value type owned by StrandsDatas |
| CStrandsDatas | CPU-authoritative strand buffer (UE FHairStrandsDatas analogue) |
| ►Nraytracing | |
| CAccelerationStructure | Bottom- or top-level acceleration structure handle |
| CDeviceAddressBuffer | Device-local buffer with shader device address (for AS builds / SBT). @ownership Owns the Vulkan buffer and memory; destroyed on release() |
| CRayTracing | Optional Vulkan KHR ray-tracing module |
| CTriangleMeshRecord | TriangleMeshRecord public API |
| CVulkanRayTracing | Vulkan implementation of IRayTracing (KHR ray-tracing pipeline) |
| ►Nvulkan | |
| CColorVertex | ColorVertex public API |
| CComputePass | Minimal compute pipeline wrapper for in-frame compute sections |
| CDeferredLightingUBO | DeferredLightingUBO public API |
| ►CFrameArena | Per-frame GPU allocation arena (host-visible coherent) |
| CAlloc | Alloc public API |
| CGpuCullParams | Cull-params UBO (std140). Mirrors GLSL CullParams in shaders/gpu_driven_cull_common.glsl (240 bytes) |
| CGpuDrivenCaps | Capabilities required for the GPU-driven path. All must be true for gpuDrivenAvailable(). Probing happens once at device creation |
| CGpuMesh | GpuMesh public API |
| CGpuShader | GpuShader public API |
| CGpuTexture | GpuTexture public API |
| ►CGraphics | EVENGINE_API_BACKENDS public API |
| ►CGpuParticleResource | |
| CSlot | |
| CLitBatch | LitBatch public API |
| ►CPbrResources | |
| CDraw | |
| CMesh3DClusteredUBO | Mesh3DClusteredUBO public API |
| CMesh3DUBO | Mesh3DUBO public API |
| CMeshShaderResources | |
| CMeshShaderResourcesDeleter | MeshShaderResourcesDeleter public API |
| CMeshVertex | MeshVertex public API |
| COffscreenCanvas | OffscreenCanvas public API |
| CPrimitive3DVertex | Clip-space vertex emitted by the backend-neutral primitive tessellator |
| CSkinPassUBO | SkinPassUBO public API |
| CTexturedVertex | TexturedVertex public API |
| CUiTextureDraw | Backend-internal textured rectangle queued by a UI presenter |
| ►Nwebgpu | |
| CAdapterDone | Instance + adapter resolved |
| CBindGroupLayoutBuilder | Fluent builder for wgpu::BindGroupLayout |
| CCapabilities | Read-only snapshot of WebGPU adapter/device limits and surface capabilities, queried once after device creation |
| CDeviceDone | Instance + adapter + device + queue + capability snapshot |
| CGpuMesh | Vertex/index buffers for one mesh |
| CGpuShader | A compiled shader: one WebGPU pipeline + layout. Also holds the WGSL sources so custom shaders can be re-pipelined for offscreen targets |
| CGpuTexture | Texture resources backed by a wgpu texture + view + sampler + bind groups |
| ►CGraphics | EVENGINE_API_BACKENDS public API |
| CLitBatch | |
| ►CPbrResources | |
| CPipeline | |
| CSolidBatch | SolidBatch public API |
| CTexturedBatch | |
| CInitFlow | Typed, blocking WebGPU initialization flow |
| CInstanceDone | Instance created, no adapter yet |
| CMesh3DClusteredUBO | Clustered-forward mesh UBO (matches the Vulkan Mesh3DClusteredUBO and the WGSL clustered Frame block) |
| CMesh3DUBO | Frame UBO for the mesh3d pipeline. Mirrors the std140 layout of the WGSL Frame block and the legacy Vulkan Mesh3DUBO (so custom shader prefixes stay compatible). See wgsl_shaders.h |
| CMeshVertex | MeshVertex public API |
| COffscreenCanvas | Offscreen render target (RGBA8Unorm color, optional Depth32Float). 2D batches are flushed into the canvas texture by Graphics::flush2DToCanvas |
| CPbrSpecializedSources | Owning WGSL stages after unreachable texture operations and declarations are removed |
| CPbrVariantLimits | Device resource limits relevant to one extended PBR shader variant |
| CPbrVariantPlan | Stable resource-layout key and checked stage counts for a PBR snapshot |
| CPbrVariantSources | Reproducibly generated full PBR WGSL sources before resource specialization |
| CPipelineBuilder | Fluent builder for wgpu::RenderPipeline |
| CSamplerBuilder | Fluent builder for wgpu::Sampler |
| CSkinPassUBO | SkinPassUBO public API |
| CAlphaMask | Reusable two-texture alpha mask for immediate 2D composition |
| CAmbientOcclusion | Screen-space ambient occlusion |
| CAntiAliasing | Classic image-space anti-aliasing |
| CAtmosphereClipmap | Nested world-space volume grids for stable large-range participating media |
| CAtmosphereClipmapLevel | One camera-centered, world-space atmosphere clipmap level |
| CAtmosphereVolume | Camera-frustum volume used by the volumetric fog passes and CPU references |
| CBatcher | Accumulates solid / textured quads in logical (Y-down) coordinates. Used by RenderSystem; not a public script API |
| CBatchVertex | CPU-side vertex for 2D batching (logical or NDC depending on stage) |
| CBloom | Linear-HDR bloom pyramid with selectable Karis/tent or Gaussian/scatter reconstruction |
| CBloomFilterSettings | Value-owned Gaussian bloom settings, independent of camera intensity and threshold |
| CCamera | 2D/3D 摄像机基类：持有变换栈并暴露投影矩阵。 |
| ►CCamera2D | Declarative 2D camera (viewport center + zoom) |
| CData | Data public API |
| ►CCamera3D | EVENGINE_API_BACKENDS public API |
| ►CData | Data public API |
| CReflectionProbe | ReflectionProbe public API |
| CCanvas | Canvas public API |
| CClusteredLightConfig | Clustered forward grid (CPU assign, GPU consume) |
| CClusteredLightingUpload | CPU-built clustered lighting upload for one frame/camera. Point lights are clustered; directional lights become the primary dir (first by intensity) |
| CClusterTableEntry | ClusterTableEntry public API |
| CDashPattern | Owning alternating draw/gap pattern for stroked primitives |
| CDepthOfField | Separable Gaussian depth-of-field for the final HDR scene |
| CDepthOfFieldFocusInput | One frame of caller-owned raycast or target observations |
| CDepthOfFieldFocusOutput | Focus and lens values ready for a depth-of-field renderer |
| CDepthOfFieldFocusSettings | Provider-neutral autofocus configuration |
| CDepthOfFieldFocusState | Persistent autofocus state owned by the caller |
| CDepthPyramid | Cross-backend min/max hardware-depth pyramid packed into one texture atlas |
| CDiffuseLightProbeRegistry | Owns generated diffuse probes and samples their baked L0 irradiance |
| CDiffuseLightProbeSample | DiffuseLightProbeSample public API |
| CDiffuseLightProbeVolumeSample | DiffuseLightProbeVolumeSample public API |
| CDrawable | Drawable base (textures, meshes, canvases) |
| CDrawItem2D | Shared 2D draw queue item (sprites + tiles) |
| CExposure | GPU percentile metering, eye adaptation, and linear HDR pre-exposure |
| CFlattenedContour2D | One flattened owning contour produced from a Path2D |
| CFogFroxel | Participating-media coefficients stored in one froxel |
| CFogVolume | Analytic local participating-media volume injected into atmospheric fog |
| ►CFont | GPU-side font: wraps a decoded font::FontData and rasterizes a fixed set of codepoints into a single RGBA8 glyph atlas texture up front, so Graphics::drawText() and Graphics::print() can draw text with plain textured-quad draws |
| CGlyph | Glyph public API |
| CFrameDrawList3D | Double-buffered per-frame draw list written by the prep jobs and only read by the render thread. Vectors keep their capacity across frames, so the steady state does not allocate per frame |
| CGBuffer | Screen-space buffers for mid/post effects and Hybrid deferred lighting |
| CGlobalIllumination | Screen-space single-bounce GI (SSGI). @lifetime All texture arguments are borrowed for the duration of each call |
| CGpuIndirectCommand | Indirect draw command; layout identical to VkDrawIndexedIndirectCommand |
| CGpuInstance | Per-instance GPU record (std430). Mirrors GLSL GpuInstance |
| CGpuMaterialRecord | GPU material table record (std430). Mirrors GLSL GpuMaterialRecord |
| CGpuMeshRecord | GPU mesh table record (std430). Mirrors GLSL GpuMeshRecord |
| CGpuParticleDraw | Parameters for rendering a resident GPU particle emitter |
| CGpuParticleSpawn | GPU particle state uploaded only for newly spawned particles |
| CGpuParticleStats | Delayed non-blocking counters from a resident GPU emitter |
| CGpuParticleUpdate | Parameters for one resident GPU simulation step |
| CGpuResidentInstanceBatch | Direct-render description for a GPU-authored array of GpuInstance records. @ownership buckets and buffer are borrowed for this call; the native buffer remains caller-owned through the frame fence as required by GpuResidentBufferView |
| CGpuResidentInstanceBucket | One contiguous mesh/material bucket in a sorted resident instance buffer |
| CGpuVegetationVertexRecord | Optional per-vertex streams used by vegetation-capable GPU-driven shaders |
| CGpuVgAssetUpload | Neutral GPU upload for one virtual-geometry asset. Raw arrays so the graphics module does not depend on the virtualgeometry module. @lifetime Every array is borrowed for the upload call only and is never retained |
| CGpuVgCluster | GPU-packed cluster node (std430, 4 x uvec4). Mirrors the virtualgeometry module's VgGpuCluster layout |
| ►CGraphics | |
| CDeferredFileTexture | DeferredFileTexture public API |
| CDisplayOutputSupport | Surface present formats the current device/window can offer |
| CEntityIdDraw | Per-pixel mesh entity-ID pass. Renders each EntityIdDraw's mesh with the given flat idColor (RGB encodes a stable entity id) into an offscreen target using the same viewProj, then reads it back to CPU. Pixels not covered by any entity are (0,0,0,0). Caller owns the returned ImageData*. Returns nullptr when the backend does not support offscreen ID capture |
| CGraphicsArtifactDescriptor | Backend-neutral mesh descriptor shared by Vulkan and WebGPU adapters |
| CGraphicsArtifactHandleTag | Owner tag for graphics artifact runtime handles |
| CGraphicsArtifactProvider | Real graphics-module provider for generated mesh publication |
| CGraphicsArtifactResource | Queryable backend-neutral mesh resource owned by the graphics module |
| CGraphicsArtifactStage | |
| ►CGrassField | Dense grass + sparse dark tufts on a mesh. Caller owns GrassField*; GPU Mesh / Shader / Texture are owned by Graphics |
| CBakeParams | BakeParams public API |
| CICanvasFactory | Narrow offscreen-Canvas allocation boundary for tools and optional modules |
| CICanvasTarget | Narrow render-target binding boundary for optional tooling modules |
| CIGraphics2D | 2D immediate-mode drawing surface (screen or offscreen Canvas) |
| CIGraphics3D | 3D frame / mesh / light / shadow rendering surface |
| CIImageResourceFactory | Backend-owned RGBA8 texture upload and release operations |
| CIMeshResourceFactory | Backend-owned mesh upload and release operations |
| CIndirectBuilder | CPU-side builder for GPU-driven indirect draws (stage 1) |
| CIPostFX | Post-process / special-effect object factory |
| CIRayTracing | Optional hardware ray-tracing backend (Vulkan KHR RT) |
| CIResourceFactory | Texture / mesh / shader / canvas creation and release |
| CISolidRectRenderer | Narrow solid-rectangle draw boundary for UI/debug tooling |
| ►CLight2D | Declarative 2D light. Collected by RenderSystem (max 8 per canvas/frame). type: "point" | "dir" | "spot" (≤15 chars) |
| CData | Data public API |
| CLight2DGpu | GPU light packing for lit2d (std140-friendly) |
| ►CLight3D | Declarative 3D light. Collected by RenderSystem3D (max 8 per frame). type: "point" | "dir" | "spot" (≤15 chars) |
| CData | Data public API |
| CLight3DGpu | GPU light packing for mesh3d / PBR (std140-friendly) |
| CLighting2DUBO | Lighting2DUBO public API |
| CLighting3DPack | Lighting3DPack public API |
| CLocalShadowSlot | One allocated local (spot/point-face) shadow slot for the frame. @ownership Ephemeral CPU descriptor; GPU layer index is valid for the frame |
| CMapFog | SLG / large-map war-fog overlay driven by a dual-scrolling cloud texture and an RGBA mask bridge (R unlock, G select, B dissolve) |
| CMaterial | Packages shading method + surface parameters into one attachable asset |
| CMesh | GPU mesh handle (+ optional CPU morph targets) |
| CMeshBackendDescriptor | Backend-owned layout facts for a mesh uploaded through Graphics |
| CMeshInstanceRange | Value-owned subset of a resource shader's static instances |
| CMeshShaderRasterState | Value snapshot of custom mesh rasterization state, independent of blending/culling |
| CModelPart | One mesh + material slot on a multi-part model (Assimp mesh / body region). When Material* is null, the owning Renderable3D MeshRenderer fields are used |
| COutline | Screen-space model outline (t3ssel8r-style), computed from the GBuffer hardware depth + world-normal buffers |
| CParallaxParams | CPU reference for simple offset parallax (matches the scale / height convention of parallax_map.glsl POM; used by unit tests, not the GPU path) |
| CPath2D | Owning backend-neutral 2D vector path |
| CPbrSurface | Owning material parameter snapshot; texture pointers remain borrowed. Base color/metallic/roughness continue to be owned by Material's existing fields. This value owns extension parameters and all eleven texture bindings |
| CPbrTextureBinding | One borrowed texture plus independently owned UV/sampler parameters. Texture is graphics-factory-owned and must outlive this binding and queued draws |
| CPbrTranslucency | Owning vegetation translucency controls, evaluated per light after normal mapping. Intensity zero disables the contribution. Color is linear HDR; intensity, direct, ambient, shadow, maskAmount, and normalDistortion are [0,1], strength is [0,50], and scattering is [1,50]. Global/overlay multipliers are finite nonnegative values |
| CPbrVegetationAlpha | TVE global-alpha controls applied after optional detail alpha blending. When enabled, masked clipping uses the Extras alpha channel and mesh variation |
| CPbrVegetationColors | Borrowed TVE Colors RGBA16F array and owning layer sampling controls. RGB is linear tint and alpha is influence; projection matches PbrVegetationExtras |
| CPbrVegetationColorStages | Owning per-fragment TVE surface-stage inputs in linear space. Scalar controls are [0,1]. Overlay RGB is finite nonnegative HDR. Overlay variation uses the mesh-authored variation channel; projection uses the |
| CPbrVegetationDetail | TVE secondary material layer evaluated after primary texture sampling. Three borrowed bindings contain secondary albedo, normal and mask data. UV mode 0 uses the primary mesh UV, 1 uses the authored TVE detail UV and 2 projects world XZ. All scalar masks are remapped with the TVE 0.0001 epsilon; reversed endpoints are valid |
| CPbrVegetationEmission | TVE emissive remap and global Extras modulation for the borrowed emissive texture binding |
| CPbrVegetationExtras | Borrowed TVE Extras RGBA16F array and owning sampling controls. Channels are emissive, wetness, overlay and alpha. UV equals coords.zw plus coords.xy times world XZ, or the model pivot XZ when usePivotPosition is true. Usage selects the sampled layer when at least 0.5 and the stored value otherwise |
| CPbrVegetationGradient | TVE mesh-height gradient tint, masked by the blended main/detail blue channel |
| CPbrVegetationMotion | Borrowed TVE Motion atlas/noise and owning explicit object-motion controls. Object mode requires an unskinned Mesh nine-float vegetation-deformation stream. Motion sampling uses the authored pivot, while repeat-addressed noise varies over each vertex's world position. Time and all controls are caller-owned snapshots; the renderer reads no clock or mutable global shader state |
| CPbrVegetationVertex | Borrowed TVE Vertex RGBA16F array and object-level size controls. TVE Plant Standard 12.6 consumes the selected layer's alpha as the object size multiplier; RGB is preserved in the atlas but is not consumed by that shader. GPU deformation samples the model pivot XZ at LOD zero and supports unskinned object-mode meshes. A Mesh vegetation-deformation stream supplies an authored local pivot; meshes without that stream use the local origin |
| CPcgGraphicsPhotoModeAuthority | Explicit owner that projects Pcg graphics fields into the live render pipeline |
| CPcgGraphicsPhotoModeState | Pcg graphics quality values retained by the active render composition |
| CPcgWaterPhotoModeAuthority | Explicit, caller-owned authority for Pcg photo-mode water reflection and underwater fog values |
| CPolylineCommand2D | One owning 2D polyline command recorded for the current frame |
| CPolylineCommand3D | One owning 3D polyline command recorded for the current frame |
| CPostEffectDesc | Backend-neutral scheduling contract supplied by post-effect modules |
| CPrimitiveAabb3D | PrimitiveAabb3D public API |
| CPrimitiveArc3D | PrimitiveArc3D public API |
| CPrimitiveArrow3D | PrimitiveArrow3D public API |
| CPrimitiveBatchUpdate | PrimitiveBatchUpdate public API |
| CPrimitiveCanvas2D | Frame-local Skia-style recorder for 2D line primitives |
| CPrimitiveCapsule3D | PrimitiveCapsule3D public API |
| CPrimitiveCone3D | PrimitiveCone3D public API |
| CPrimitiveCylinder3D | PrimitiveCylinder3D public API |
| CPrimitiveDescriptor3D | One persistent scene primitive owned by PrimitiveScene |
| CPrimitiveDisk3D | PrimitiveDisk3D public API |
| CPrimitiveDrawStatistics | Per-frame observable primitive workload |
| CPrimitiveFrustum3D | PrimitiveFrustum3D public API |
| CPrimitiveGrid3D | PrimitiveGrid3D public API |
| CPrimitiveHandle | Instance-qualified persistent primitive handle |
| CPrimitiveObb3D | PrimitiveObb3D public API |
| CPrimitivePaint | Backend-neutral fill and stroke paint |
| CPrimitivePolyline3D | Owning persistent polyline descriptor |
| CPrimitiveScene | Authoritative owner for primitives that persist across frames |
| CPrimitiveSceneCanvas3D | Frame-local scene recorder for 3D line primitives |
| CPrimitiveSphere3D | PrimitiveSphere3D public API |
| CPrimitiveTriangleVertex | Resolved triangle vertex consumed by primitive GPU backends |
| CQuad | Pixel-space sub-rectangle of a Texture (atlas cell / sprite frame). UV conversion uses the texture's logical width/height |
| CRadialTessellation | Quality and screen-error policy used by circles and curved spatial primitives |
| CRayTracingCaps | Hardware ray-tracing capabilities probed once at Vulkan device creation |
| CReflectionProbeCapture | Incremental six-face HDR scene capture for a runtime reflection probe |
| CReflectionProbeRegistry | Scene-level stable selection of published reflection probes for a camera |
| ►CReflectionProbeUpload | ReflectionProbeUpload public API |
| CProbe | Probe public API |
| ►CRenderable2D | Default renderable entity for declarative 2D sprites / solid quads |
| CSprite | |
| CTransform2D | Transform2D public API |
| ►CRenderable3D | EVENGINE_API_BACKENDS public API |
| ►CMeshRenderer | |
| CLodRendererState | LodRendererState public API |
| CTransform3D | Transform3D public API |
| CRenderControl | Declarative, compilable 3D render control |
| CRenderItem3D | One resolved 3D draw, produced by the frame data prep jobs |
| CRenderSystem | Walks ECS Renderable2D views and draws via Graphics batch path |
| CRenderSystem3D | EVENGINE_API_BACKENDS public API |
| CResolvedPrimitiveBatch2D | One contiguous 2D blend/order batch in the resolved vertex stream |
| CResolvedPrimitiveBatch3D | One contiguous 3D pipeline/sort batch in the resolved vertex stream |
| CResolvedPrimitiveTriangles | Owning backend-neutral triangle stream for one primitive pass |
| CSceneDrawContext | Immutable camera and viewport facts used to resolve one 3D draw list. Projection uses the engine's RH, zero-to-one depth, Vulkan Y-down convention and backends adapt these shared clip coordinates at submission |
| CScenePrimitivePaint | Additional scene-pass state carried by every 3D command |
| CScreenSpaceReflection | Screen-space reflections (SSR) as a fullscreen post pass. @lifetime All Graphics and texture arguments are borrowed by this effect |
| CShader | Custom GPU program |
| CShaderImageInput | Synchronous borrowed input for one immutable shader image. @ownership The caller owns bytes; upload copies them before returning. @lifetime All spans need remain valid only for the upload call; never retained |
| CShaderImageRegion | One validated byte region for an image's layer/mip upload |
| CShaderResourceInputs | Inputs for descriptor set 1 of a resource mesh program |
| CShadowConfig | ShadowConfig public API |
| CShadowPagingView | Camera context used to score local shadow candidates for atlas paging. @ownership Ephemeral; valid only for the selectShadowCasters call |
| CShadowSchemeSettings | Process-wide defaults for creating shadows per light family |
| CShadowUBO | Per-frame / per-draw CSM + local-spot constants (std140) |
| CShadowUpload | ShadowUpload public API |
| CSkyAtmosphereFrame | One atomic render snapshot, independent of view count or wall-clock time |
| CSkyAtmosphereParameters | Spherical atmospheric coefficients in inverse kilometres and kilometre heights |
| ►CSkyAtmospherePass | Prepared HDR atmospheric sky draw with independent optical parameters and lookup tables |
| CImpl | |
| CSkyCelestialLight | Explicit celestial lighting snapshot; unit direction points towards the light |
| CSkyDaylightLayer | Immutable clear-sky daylight material controls, copied during sky preparation |
| CSkyHeightFogParameters | Analytic background height fog in metre units, independent of legacy scene fog |
| ►CSkyWispsAsset | Immutable owned sky mesh and textures, loaded from a pack or generated procedurally |
| CImpl | |
| CSkyWispsLayer | Borrowed authored thin-cloud layer, consumed synchronously by sky preparation |
| CSparseVolumeTexture | Brick-sparse, pre-bakeable participating-media texture |
| CStrokeStyle | Backend-neutral stroke state shared by 2D and 3D canvases |
| CTexCellBombParams | CPU reference for texture cell-bombing math (matches tex_cell_bomb.glsl). Used by unit tests; the GPU path lives in mesh3d*.frag |
| CTexture | GPU texture created via Graphics::newTexture. Owns GPU resources through an opaque backend handle |
| CTextureCreateInfo | Options for Graphics::newTexture / newCubemap. When generateMipmaps is true and sampler.mipmap is Disabled, mipmap mode becomes Linear |
| CTextureRegionUpload | One borrowed RGBA8 source rectangle for a batched texture update. @ownership rgba remains owned by the caller and is never retained. @lifetime The byte span must remain valid through updateTextureRegions() |
| CTextureSampler | Sampler state for a Texture (filter, wrap, mip LOD, anisotropy). Defaults match historical engine behaviour: linear, clamp, no mips, no aniso |
| CTransform | 矩阵变换栈（2D/3D）：旋转/缩放/平移 + push/pop。 |
| CTreeWindProfile | Caller-owned tree prototype wind geometry matching Pcg ResourceProtoTree inputs |
| CTriangleCommand2D | One owning filled 2D triangle command |
| CTriangleCommand3D | One owning filled 3D triangle command |
| CTvePackedVertex | Immediate adapter input for TVE 12.x packed mesh streams, before UV truncation. This is an owning CPU value, not a persistent native file format. UV0 and UV1 must retain all four source components; Unity UV4 is texcoord3 here |
| CUnderwaterColorGradient | Caller-owned ordered color gradient used for depth or time-of-day fog |
| CUnderwaterColorStop | One normalized RGB key in a Pcg underwater fog gradient |
| CUnderwaterScalarCurve | Caller-owned normalized scalar curve used by Pcg underwater post exposure |
| CVegetationAtlas | Four owning arrays in row-major X/Z order at texel centers |
| CVegetationChannelAtlas | One owning vegetation channel in row-major X/Z order at texel centers. Channel atlases may use independent dimensions and world mappings when published as a GPU field set |
| CVegetationDetailRuntime | Detached render values produced from one validated Global Details publication. PBR texture pointers remain borrowed with the same lifetime as the input surface |
| CVegetationDetailSettings | TVE Global Details values, independent of scene components and global shader state |
| CVegetationElement | Owning element definition; no scene, texture or entity pointers survive admission. Center/extents are world units; yaw is radians around +Y. Layer bits select 0..8. Mask alpha multiplies opacity and mask RGB multiplies the target RGB. Equal priorities preserve input order. Seasons interpolate winter/spring/summer/autumn |
| CVegetationField | Backend-independent, owning vegetation influence field. Single writer; concurrent const evaluation is safe while no replace occurs. No callbacks, external resources, global singleton, ECS mutation or wall clock. Returned samples/atlases are owning projections, never additional mutable authority |
| CVegetationGeometry | Owning geometry projection, packed world XYZ positions and unit normals |
| CVegetationGlobals | Owning global defaults. Extras = emission, wetness, overlay, alpha. Motion = signed world X/Z direction, wind power, interaction displacement. Vertex = signed X/Z tilt, world height offset, size multiplier. Color = linear RGB tint and replacement factor; zero multiplies, one replaces |
| CVegetationGpuAtlas | Immutable GPU projection of nine layers from one vegetation field channel. The source field remains authoritative; fieldRevision detects stale projections. Texture ownership remains with factory and the caller must release it through that factory |
| CVegetationGpuFieldSet | Coherent detached projections for all four vegetation channels. Textures are factory-owned. The caller must release the set through releaseVegetationGpuFieldSet on the same graphics thread and factory |
| CVegetationGpuRuntime | Runtime-owned global inputs shared by one coherent vegetation field binding. Time is explicit for deterministic replay. Noise and atlas textures remain borrowed |
| CVegetationMask | Owning linear RGBA mask, sampled bilinearly with clamped addressing |
| CVegetationMotion | Source-equivalent plant motion parameters with explicit time and texture inputs. All data is owned. No wall clock/RNG/global shader state is read. Noise is linear RGBA with bilinear repeat addressing. The built-in 2x2 pattern is a native default; matching an authored appearance requires the same noise texture as the source. Speed/scale/amplitude controls retain TVE 12.6 plant shader units. Object transforms must be finite, affine and invertible. Output geometry is world space |
| CVegetationSample | Owning sampled field channels; no lifetime dependency on the field |
| CVegetationSurface | Owning surface inputs, supplied afresh to avoid accumulating tint/wetness across frames. Color inputs are linear. Overlay, wetness, projection and occlusion controls are [0,1]. The fragment stage derives the final overlay mask from mesh variation and occlusion, the mapped normal and textured luminance. It then applies overlay color/normal/material response followed by wetness color/normal/smoothness |
| CVegetationVertex | Owning rest vertex in object space, with unpacked authoring channels. Bending/branch/flutter/variation/occlusion/detail are [0,1]. Bounds are meters. A pivot and variation shared by one plant preserve coherent motion after mesh combining |
| CVegetationWindAudioState | Caller-owned state for Pcg WindManager's looping wind-audio volume controller |
| CVegetationWindInput | Explicit source PW_GeneralWind inputs in object/world coordinates |
| CVegetationWindProfile | Caller-owned material wind controls; billboard suppresses source branch and leaf motion. AlphaTest controls leaf motion only, independently of the renderer's alpha discard |
| CVegetationWindState | Caller-owned wind globals; no hidden clock, singleton or retained scene link |
| CVirtualTextureBlend | CPU reference implementation of a tiled, height-aware material virtual texture |
| CVirtualTextureBlendConfig | Backend-neutral configuration for a paged material-attribute texture |
| CVirtualTextureBlendLayer | One immutable source layer copied into a VirtualTextureBlend |
| CVirtualTextureBlendStats | Observable residency counters for virtual-texture diagnostics |
| CVirtualTexturePageId | Mip-zero virtual page selected for physical residency |
| CVirtualTextureResidentSet | CPU images and sampling metadata for one atomically publishable physical cache |
| ►CVolumeDensityGraph | Compact acyclic program that evaluates procedural volume density |
| CNode | |
| CVolumetric | Volumetric light + fog |
| CVolumetricLight | Local light injected into participating media |
| CWater | Dynamic water surface with sky reflection and animated ripples |
| CWaterDepthGradient | Caller-owned color and alpha keys used to bake a water depth-ramp texture |
| CWaterfall | Flowing waterfall (falling water sheet) rendered on a vertical plane |
| CWaterGradientAlphaStop | One linear alpha stop in a Pcg-compatible water depth gradient |
| CWaterGradientColorStop | One linear RGB stop in a Pcg-compatible water depth gradient |
| CWaterMeshSettings | Authored dimensions and density for Pcg-compatible procedural water geometry |
| CWaterPlanarReflectionInput | Immutable camera and horizontal water-plane inputs for a reflection capture |
| CWaterPlanarReflectionPlan | Complete, caller-owned plan for configuring a mirrored capture camera |
| CWaterPlanarReflectionSettings | Authored planar-reflection policy with no camera or texture ownership |
| CWaterReflectionMasker | Own a CPU snapshot of Pcg's planar-reflection mask and evaluate player movement against it |
| CWaterSceneConditions | Immutable scene inputs used to decide whether water reflections are stale |
| CWaterStyleConfig | Versioned, backend-neutral configuration for the built-in stylized water surface |
| CWaterSurfaceFogSnapshot | Caller-owned surface fog values restored after leaving or disabling underwater effects |
| CWaterSurfaceMaterialSnapshot | Caller-owned water-renderable tint restored outside the underwater state |
| CWaterSurfacePostFxSnapshot | Caller-owned surface post-processing values restored above water |
| CWaterSystemSettings | Authored policy for Pcg-compatible water placement and reflection refresh |
| CWaterSystemState | Caller-owned water-system state; contains no scene pointers or hidden clock |
| CWaterUnderwaterDisableTriggerState | Caller-owned enable state driven by Pcg disable-underwater trigger events |
| CWaterUnderwaterInput | Immutable per-frame water, camera and lighting snapshot |
| CWaterUnderwaterOutput | Effects snapshot for graphics, audio, particles and VFX providers to consume |
| CWaterUnderwaterSettings | Authored Pcg underwater-effects policy; owns no renderer, audio source or scene object |
| CWaterUnderwaterState | Persistent caller-owned transition and caustic animation state |
| CWaterUnderwaterTriggerEvent | Immutable normalized 3D trigger event snapshot supplied by the physics owner |
| CWebGpuArtifactDescriptorAdapter | Computes the same descriptor a WebGPU backend would expose without a device |
| ►Ngraphics_editing | |
| CGraphicsOffscreenPreviewService | Concrete Graphics/Canvas preview bridge with revision-safe artifact storage |
| COffscreenPreviewArtifact | In-memory artifact metadata returned after synchronous readback |
| COffscreenPreviewRequest | Immutable request for one isolated Canvas render and CPU readback |
| CPrimitiveGizmoRenderer | Converts renderer-neutral editor gizmos into one atomic primitive draw submission |
| CVegetationFieldGizmoBuilder | Bounded renderer-neutral viewport projection for one vegetation influence field |
| CVegetationFieldTarget | Owning editor document whose runtime projection is one VegetationField. Element IDs remain stable while priority changes reorder the runtime projection. The live field is borrowed and must outlive this main-thread-affine target. No callbacks are invoked |
| ►Ngraphics_editor | |
| CGraphicsEditorModule | Script composition module for graphics-domain editor helpers |
| ►Ngrid | |
| CGridConfig | Grid shape, cell metrics, origin, and placement plane. Pure data; use GridProjection helpers for world/cell conversion |
| ►Nhd2d | |
| CHd2D | HD-2D module: tilemap-to-3D extrusion + 2D sprites as 3D billboards |
| CHd2dLook | HD-2D presentation look inspired by HD2DURP (DOF + bloom + pixel sampling) |
| CSprite3D | Camera-facing 2D sprite billboard rendered inside the 3D scene |
| CTileMap3D | Extrudes a 2D tile layer into a 3D terrain mesh (HD-2D ground) |
| ►Nhd2d_editing | |
| CHd2dAssetValue | Authored HD-2D sprite-sheet and tile-extrusion preset |
| CHd2dDocumentRuntime | Candidate-first live Sprite3D/TileMap3D preset publication |
| CHd2dDocumentTarget | Revisioned HD-2D sprite/tilemap presentation asset |
| CHd2dFramePreview | Deterministically sampled sprite-sheet frame and UV rectangle |
| CHd2dFramePreviewService | Pure sprite animation scrub evaluator |
| CIHd2dTextureResolver | Resolves an HD-2D sprite texture |
| ►Nheightmap_target | |
| CHeightmapTargetModule | Script-facing composition module for live heightmap editing targets |
| CTerrainDocumentData | Owning editable terrain state restored from one document snapshot |
| CTerrainDocumentLimits | Allocation limits checked before an editor terrain document is materialized |
| ►Nhexmap | |
| CEdgeVertices | Five sample points along one hex edge, from v1 to v5 |
| CHexCellData | One cell of the hex map: packed values plus packed flags |
| CHexCoordinates | Axial coordinates of one hex cell |
| CHexFlags | Packed boolean cell state (roads, rivers, walls, exploration) |
| CHexHash | Five-component pseudo-random value used to pick and orient one feature |
| CHexHashGrid | Deterministic replacement for the reference project's hash grid |
| CHexMap | An editable, chunked, pointy-top hex map |
| CHexMapGeneratorSettings | Tunables of the reference project's map generator |
| CHexMapModule | Owns the active hex map and the GPU meshes generated from it |
| CHexMeshData | CPU-side triangle soup for one hex chunk surface |
| CHexMetrics | Hexagon metrics shared by the map model and every mesh builder |
| CHexMoveRules | Movement tuning of one actor; cells per turn and vision radius in cells |
| CHexNoise | Deterministic four-channel value noise over the XZ plane |
| CHexPath | One found path: the cells from origin to goal, with the turn each one is reached on |
| CHexSearchContext | Reusable search scratch: one record per cell plus a priority bucket queue |
| CHexSearchData | Per-cell scratch record of one search |
| CHexSphereGeneratorSettings | Tunables of the spherical generator |
| CHexSphereMap | An editable hex map wrapped onto a sphere |
| CHexSphereTopology | Icosahedral (Goldberg) hex topology for a spherical hex map |
| CHexSurfaceId | Stable identifier of one chunk surface stream |
| CHexTerrainBake | Packed terrain produced by a generator and applied onto a hex map |
| CHexTerrainVertexCode | Encodes the three contributing cells of a terrain vertex |
| CHexTerrainWeights | Terrain-layer weights of a vertex; the three entries sum to 1 |
| CHexUnitRegistry | Owns the units of one map and their fog-of-war contribution |
| CHexUnitSample | Snapshot of one unit used to drive rendering |
| CHexUnitState | Serializable state of one unit |
| CHexUnitTuning | Per-unit tuning shared by every unit of a registry |
| CHexValues | Packed numeric cell state |
| CHexVec3 | Minimal 3-component float vector used by the hex mesh builders |
| CHexVec4 | Four-component float vector, matching the reference four-channel noise sample |
| CHexVisibility | Fog-of-war bookkeeping: how many viewers currently see each cell |
| ►Nhousegen | |
| CHouseComponent | 房屋组件模板（几何 + 连接点 + 权重）。 |
| CHouseComponentLibrary | 房屋组件注册表（按 id 索引，支持分类/风格查询）。 |
| CHouseGen | 程序化房屋生成模块（eve.HouseGen）：组件库 + 布局生成。 |
| CHouseGenerator | 布局生成器：把 HouseRequest 解析为 HouseLayout（组件库驱动）。 |
| CHouseInstance | 布局中的单个组件实例（位置 + 旋转）。 |
| CHouseLayout | 一次生成的房屋布局：实例 + 房间 + 元信息，可 JSON 序列化 / 实例化。 |
| CHouseMaterialOverride | 组件材质覆盖（未设置的字段沿用默认材质）。 |
| CHousePolygonPoint | 自由轮廓占地的一个多边形顶点（角坐标，[0,width]×[0,depth]）。 |
| CHouseRequest | 一次房屋生成请求（参数集）。 |
| CHouseRoom | 布局中的房间标记。 |
| CHouseSocket | 组件连接点：方向 + 类型 + 可接受类型。 |
| ►Nhousegen_editing | |
| CHouseGenDocumentTarget | Revisioned component-kit and deterministic generation-request asset |
| CHouseGenPreviewRuntime | Candidate generation containing a validated library and deterministic layout |
| CHouseKitComponentValue | Authored house component with stable editor identity |
| ►Ni18n | |
| CI18n | Game localization (i18n) module |
| ►Nik | |
| ►Ndetail | |
| CChainOptions | Options shared by the chain-scoped FABRIK solve used by Solver2D / Solver3D. These mirror the knobs of ik::solver plus wrapper-level pose blending |
| CIK | Inverse Kinematics module — wraps header-only sunxfancy/ik.hpp (FABRIK). Script: ik <- eve.IK(); |
| CSkeleton2D | Script-facing 2D skeleton + pose state (ik::skeleton2d + ik::ecs2d). Bone indices are stable after each createBone / topological refresh. Root bone is always id 0 |
| CSkeleton3D | Script-facing 3D skeleton + pose state (ik::skeleton3d + ik::ecs3d). Local angles are yaw/pitch in the parent bone frame |
| CSolver2D | FABRIK solver for Skeleton2D. Script type: Solver2D |
| CSolver3D | FABRIK solver for Skeleton3D. Script type: Solver3D |
| ►Nimage | |
| CImage | This module is responsible for decoding files such as PNG, GIF, JPEG into raw pixel data, as well as parsing compressed formats which are designed to be uploaded to the GPU and rendered without being un-compressed. This module does not know how to draw images on screen; only love.graphics knows that |
| ►CImageData | Represents raw pixel data |
| CPixel | Pixel public API |
| CRow | |
| CUvPaintReceipt | Owning receipt for one UV-space raster paint operation |
| CUvPaintRegion | Reusable renderer-neutral bounds for one normalized UV paint operation |
| CUvPaintSession | Transactional, renderer-independent UV texture painting session |
| CWebPHandler | Internal decoder adapter; each call owns its output and borrows input synchronously |
| ►Ninput_editing | |
| CInputActionValue | InputActionValue public API |
| CInputBindingCapture | Captures the first intentional control movement for a rebind UI |
| CInputBindingValue | InputBindingValue public API |
| CInputControlSample | InputControlSample public API |
| CInputMapEvaluator | Deterministically evaluates raw device samples against an authored action map |
| CInputMapTarget | EVENGINE_API_BACKENDS public API |
| ►Ninventory | 运行时容器：固定格数的背包 / 箱子 / 商店栏等。 行为由 InventorySystem 提供；本类暴露便于脚本绑定的薄封装方法。 |
| CBag | 格子型物品容器（脚本可直接操作）。 |
| CEquipmentSet | EVENGINE_API_FOUNDATION public API |
| CInventory | 背包模块（eve.Inventory）。 |
| CInventoryChangeEvent | 一次成功库存变更的事件（供脚本 poll / C++ hook）。 |
| ►CInventoryContainerAdapter | Adapts one Bag or EquipmentSet without changing their legacy APIs |
| CPreparedState | |
| CInventoryContainerObject | Owning transfer payload for one inventory stack |
| CInventoryControl | Exposes the module's published player inventories through the shared gameplay command protocol |
| CInventoryItemGrant | One exact item quantity requested by an atomic inventory batch |
| CInventoryResourceAccount | Adapts one Bag's item quantities to the common resource protocol |
| ►CInventorySaveSession | Coordinates persistent inventory owners without duplicating their live state |
| CPreparedRestore | Validated owning inventory state awaiting publication |
| CInventorySystem | EVENGINE_API_FOUNDATION public API |
| CItemCostAdapter | Creates canonical costs for item and ammunition quantities |
| CItemDefinition | 物品模板（进程级注册表中的定义，不含运行时数量）。 |
| CItemRegistry | EVENGINE_API_FOUNDATION public API |
| CItemStack | 容器中的一格堆叠（空槽：itemId 为空或 quantity <= 0）。 |
| ►CPreparedInventoryAdd | Move-only, validated inventory state prepared for one Bag |
| CState | |
| ►CPreparedInventoryRemove | Move-only, validated inventory removal prepared for one Bag |
| CState | |
| ►Njoystick | |
| ►Nsdl | |
| CJoystick | SDL joystick/gamepad module backend (device enumeration and mappings) |
| CPad | SDL joystick/gamepad backend (GameController + optional haptic rumble) |
| CJoystick | Joystick / gamepad manager. Tracks connected pads and gamecontroller mappings |
| CPad | One connected (or previously connected) joystick / gamepad device. Gamepad axis/button names follow SDL GameController strings (e.g. "leftx", "a", "dpup"). Hat directions: c/u/d/l/r/lu/ld/ru/rd |
| ►Njson | |
| CDocument | EVENGINE_API_FOUNDATION public API |
| CNode | |
| CValue | EVENGINE_API_FOUNDATION public API |
| ►Nkeyboard | |
| ►Nsdl | |
| CKeyboard | SDL keyboard backend implementing eve::keyboard::Keyboard |
| CKeyboard | Keyboard input. Key / scancode names follow SDL naming (SDL_GetKeyName / SDL_GetScancodeName), e.g. "A", "Return", "Left Ctrl" |
| ►Nlevel_editing | |
| CBrush | Unity GridBrushBase-inspired tile brush. Operates on TileBuffer; exposes preview + change list for UI / undo |
| CEditorHistory | Undo/redo stack: opaque string actions + optional tile change groups that can apply directly to a TileBuffer |
| CLevelDocument | Format-neutral, editable top-down level model |
| CLevelFormat | Plug-in contract for importing and exporting a level representation |
| CLevelFormatCodec | |
| CLevelFormatRegistry | Registry and conversion gateway for level formats |
| CLevelLayer | A tile or object layer in a LevelDocument |
| CLevelObject | One freely extensible object placed in a top-down level |
| CTileBuffer | Independent GID grid for map brushes (no hard dependency on map.TileLayer) |
| CTileBufferTarget | Non-owning IIntFieldTarget adapter for TileBuffer |
| ►Nlevel_editor | |
| CLevelEditorModule | Script composition adapter for tile-oriented level authoring |
| ►Nlighting_editing | |
| CEnvironmentDocumentTarget | Serializable shared environment target for static, DayNight and Weather modes |
| CEnvironmentRuntimeApplier | Optional bridge applying environment properties to DayNight or Weather |
| CLight3DDocumentTarget | Serializable property target matching graphics::Light3D |
| CLight3DRuntimeApplier | Optional bridge applying a light document to graphics::Light3D |
| CLightingPropertyTargetBase | Shared property-document implementation for light and environment targets |
| CSnowFieldTarget | Non-owning scalar-field adapter for a live interactive snow field |
| ►Nlocalization_editing | |
| CLocalizationAnalysis | Completeness analysis result with key/locale-scoped diagnostics |
| CLocalizationDocument | UI-neutral localization table with deterministic persistence and QA |
| CLocalizationLocaleCoverage | Aggregate production coverage for one locale |
| CLocalizationRow | One stable localization key and all locale variants |
| CLocalizationVariant | One locale's editable translation and voice-production metadata |
| CLocalizationVoiceAudition | Optional bridge registering and playing localized voice through DialogueVoice |
| ►Nmap | 放置世界：格子占用（多通道）+ 地形语义 + 已放置建筑实例。 行为由 PlacementSystem 提供；本类暴露便于脚本绑定的薄封装方法。 坐标换算统一走 eve::grid（支持 rectangle / iso / staggered / hex 与 XY/XZ 平面轴）。 |
| CDualGridMaskAtlas | Owning CPU result containing all 16 dual-grid masks and their signed-distance fields |
| CDualGridMaskConfig | Deterministic settings for the reusable 16-frame procedural transition-mask atlas |
| CDualGridOptions | Dual-grid autotile (Oskar Stålberg style) |
| CDualGridRgbaImage | Owning RGBA8 image used by the renderer-neutral transition-atlas baker |
| CFlowField | Integration + direction field for group pathfinding to a single goal. nextX/nextY point to the neighboring cell with lower cost (toward goal). At the goal, next points to itself |
| ►CFov | Dynamic field-of-view / fog-of-war facade. Phase A: 2D shadowcast + multi-revealer + explored memory. Phase B: raycast/permissive, heightmap, volume, dirty-skip, CPU masks. Phase C: hex topology FOV, rectangle-based FOV, perception/stealth detection helpers, GPU mask Texture upload |
| ►CImpl | |
| CAngleShadow | |
| CRect | |
| CRevealer | |
| CSnapshot | Owning visibility-memory snapshot for the current grid/volume dimensions |
| CITileCollisionSink | Optional sink implemented by a physics or project adapter |
| CMap | Map module — factory + script binding for 2D tilemaps. Per-frame: TileConfigSystem (hot reload) → unified sprite+tile render. Pathfinding: newPathfinder / newPathfinderSize → A* + Flow Field group paths. FOV: newFov / newFovSize → shadowcast visibility + explored memory |
| CMapArtifactHandleTag | Owner tag for map artifact runtime handles |
| CMapArtifactProvider | Real map-module provider for generated grid publication |
| CMapArtifactRecord | Queryable map record containing the copied semantic topology |
| CMapArtifactStage | |
| CMapObject | A named, typed rectangle object from a Tiled objectgroup layer. Used by Map::setObjects / getObject* for gameplay spawn points, triggers, etc |
| ►CPath | Ordered tile-index waypoints from start to goal (inclusive) |
| CCell | One waypoint |
| ►CPathfinder | Pathfinding facade. Single-agent: A*. Group (same goal): Flow Field + follow. Grid/topology internals stay out of the public ABI (Windows export limit) |
| CImpl | |
| CRpgMakerImportReceipt | Transactional RPG Maker MV/MZ import receipt |
| CTileCollisionRect | One greedily merged solid tile rectangle in world coordinates |
| CTileConfigSystem | Polls bound config files (Resource.path) and hot-reloads when modtime changes. Returns number of layers reloaded |
| ►CTileLayer | ECS tile layer entity. Script mutates tile GIDs / tileset / draw; TileRenderSystem batch-draws atlas quads (or solid debug colors when no texture) |
| CConfig | Config public API |
| CDraw | |
| CResource | |
| ►CTiles | |
| CChunk | Chunk public API |
| ►CTileset | |
| CAnimation | Animation public API |
| CAnimationFrame | AnimationFrame public API |
| CAtlas | One Tiled atlas selected by the greatest firstGid not exceeding a GID |
| CCustomData | CustomData public API |
| CTerrainFamily | Versioned logical terrain family consumed by the canonical resolver |
| CTerrainRule | TerrainRule public API |
| ►CVisual | Per-GID visual metadata emitted by a project-defined asset pipeline |
| CCollisionShape | CollisionShape public API |
| CSubtile | Subtile public API |
| CSubtileFrame | SubtileFrame public API |
| CTileRenderSystem | Draws all visible TileLayer entities via Graphics batch path (UV atlas quads) |
| ►Nmap_editing | |
| CIMapRoadMeshSink | Runtime-neutral sink receiving revision-tagged generated road meshes |
| CIMapStructureEditTarget | Layer, spline and placement editing capability for map presenters |
| CMapDocumentTarget | UI-neutral map structure document with reversible domain operations |
| CMapLayerRecord | Stable map layer descriptor used by outliner presenters |
| CMapObjectImporter | Converts external object records into one atomic placement transaction plan |
| CMapObjectImportPlan | Side-effect-free batch import plan for map object placements |
| CMapObjectImportRecord | Imported object record before stable placement ids are assigned |
| CMapPlacementRecord | Stable object placement stored on an object layer |
| CMapRoadMeshPublisher | Publishes validated road previews while rejecting stale document revisions |
| CMapRoadPreviewResult | Deterministic renderer-neutral road strip preview |
| CMapRoadRecord | Road spline authoring record independent from rendering/mesh generation |
| CMapSplinePointRecord | Stable editable control point in a road or path spline |
| CTileLayerTarget | Non-owning editable adapter for a live map tile layer |
| ►Nmaterial_editing | |
| CIMaterialBatchRuntimeSink | Atomic publication boundary for a complete multi-material candidate |
| CIMaterialRuntimeSink | Atomic runtime publication boundary for a complete material candidate |
| CMaterialBatchTarget | One editor transaction target for mixed-value, multi-material property editing. Owns all authoring documents and publishes a complete candidate set through one atomic sink call |
| CMaterialCompileResult | Material graph compilation value; artifact is published separately |
| CMaterialDocumentTarget | UI-neutral, serializable material authoring target |
| CMaterialEditorService | Revision-aware material compile result and preview publication service |
| CMaterialGraphDomain | Minimal material domain with typed pin validation and deterministic compile artifacts |
| CMaterialPublishingTarget | Candidate-first material operation target with live commit/undo publication |
| ►Nmaterial_editor | |
| ►CMaterialEditorModule | Composition adapter that contributes material editing commands and automation targets |
| CTargetFactory | |
| ►Nmath | |
| ►Nsteering | |
| CVector2 | Stateless steering vector algorithms shared by 2D and 3D callers |
| CVector3 | Plain 3D value used by the stateless steering calculations |
| CMat4 | Column-major 4x4 matrix wrapping glm::mat4 |
| CMath | Math module — glm-backed vectors/matrices, noise, bezier, random. Script: math <- eve.Math(); |
| CVec2 | 2D float vector (script-facing math module value) |
| CVec3 | 3D float vector (script-facing math module value) |
| ►Nmodel3d | |
| CEveFileSystem | Medialoader::FileSystem adapter over eve::filesystem (physfs / VFS) |
| CModel3D | Resource module for decoding 3D models via medialoader (Assimp). Produces ModelData; GPU upload is graphics' responsibility |
| CModelData | CPU-side decoded 3D model (Assimp scene owned via medialoader::ModelScene). Does not upload to GPU — use graphics::Graphics::newMeshFromAssimp on getMesh() |
| CModelLoadOptions | Toggles for the Assimp post-processing steps applied by medialoader on decode. All default to on (matches the historical behavior); disabling a step changes vertex/triangle layout (e.g. joinIdenticalVertices=false keeps per-face vertices for hard-edged flat shading). Normals are generated with aiProcess_GenSmoothNormals when a mesh lacks them (see the configure-time medialoader patch in CMakeLists.txt), keeping hard seams beyond the 80-degree smoothing angle |
| CModelRenderOptions | ModelRenderOptions public API |
| CSurfaceUv | Owning result of mapping a triangle-local surface point to one UV channel |
| ►Nmouse | |
| ►Nsdl | |
| CCursor | SDL mouse cursor (custom image or named system cursor) |
| CMouse | SDL mouse backend implementing eve::mouse::Mouse |
| CCursor | Opaque mouse cursor (system-defined or custom image) |
| CMouse | Queries and manipulates the mouse cursor; creates custom cursors |
| ►Nnetwork | |
| CChannel | Length-prefixed (big-endian uint32) message framing over a TcpSocket. sendMsg() writes one framed message; feed() consumes bytes and emits received frames as "chmsg" events on the main thread via the Event module |
| CHttpRequest | Asynchronous HTTP request (Poco-based). Configure headers/body, call submit(), then receive the response through Network::pump as a NetEvType::HttpResp completion |
| CNetCompletion | One asynchronous network result/event. handle points at the originating TcpSocket/UdpSocket/HttpRequest/Channel; bytes carries received data; peer/reason/status describe connection context |
| CNetHost | EVENGINE_API_PLATFORM public API |
| CNetReader | EVENGINE_API_PLATFORM public API |
| CNetRpc | EVENGINE_API_PLATFORM public API |
| CNetTelemetrySnapshot | Copied aggregate counters for editor/profiler network inspection |
| CNetwork | Network module: TCP/UDP/HTTP factories, background worker, and completion event plumbing. Script: net <- eve.Network(); |
| CNetWorker | Background thread that runs blocking socket I/O and HTTP jobs. Completions are queued and drained by Network::pump on the main thread |
| CNetWriter | EVENGINE_API_PLATFORM public API |
| CSession | Named collection of Channels (a "session"). Lookup by name, close all. Does not own the channels; the caller owns them |
| CTcpSocket | TCP socket backed by Poco::Net; supports both client (connect) and server (listen/accept) roles. Data arrives via Network::pump as NetCompletion |
| CUdpLink | EVENGINE_API_PLATFORM public API |
| CUdpSocket | UDP socket backed by Poco::Net; supports connect/bind and datagram send |
| ►Nnetwork_editing | |
| CNetworkTelemetryCollector | Optional bridge collecting a copied snapshot from the Network module |
| CNetworkTelemetryModel | UI-independent bounded history and network health diagnostics |
| CNetworkTelemetrySample | One copied network telemetry sample; safe after the runtime module changes |
| ►Nnpc_ai | |
| CAgentArchive | Versioned, owning NPC state used for save/load and hot-reload handoff |
| CAgentHandleTag | AgentHandleTag public API |
| CAgentSnapshot | AgentSnapshot public API |
| CBehaviorDefinition | Immutable, validated source data for one hierarchical NPC state tree |
| CBlackboardKeySpec | BlackboardKeySpec public API |
| CBlackboardPredicate | BlackboardPredicate public API |
| CINavigationProvider | Narrow asynchronous pathfinding and locomotion provider contract. @thread Calls are simulation-thread-affine unless an implementation documents stronger guarantees. @reentrancy Implementations must not call back into NpcAiWorld or NavigationTaskService |
| CINavigationRequestFactory | Builds a typed navigation request from an authored task and current agent projection |
| CITaskService | Owned extension point for navigation, animation, combat and gameplay tasks. @thread All calls are simulation-thread-affine. @reentrancy Implementations must not call back into the owning NpcAiWorld |
| CNavigationProgress | NavigationProgress public API |
| CNavigationRequest | NavigationRequest public API |
| CNavigationTaskService | ITaskService adapter for asynchronous move-to requests |
| CNavigationTicketTag | NavigationTicketTag public API |
| CNpcAgentState | Authoritative gameplay-entity link to one module-owned NPC agent |
| CNpcAi | Factory module for script-owned NPC AI worlds |
| CNpcAiEcsStepReport | NpcAiEcsStepReport public API |
| CNpcAiEcsSystem | Gameplay-decision phase adapter over a caller-selected existing entity root |
| CNpcAiProjection | Cold derived, local-only projection for rendering, editor and gameplay inspection |
| CNpcAiSystemContract | NpcAiSystemContract public API |
| CNpcAiWorld | Authoritative owner and deterministic scheduler for NPC AI agents |
| CNpcAiWorldConfig | NpcAiWorldConfig public API |
| CPerceptionMemory | One bounded, expiring item of NPC perception memory |
| CSmartObjectCandidate | SmartObjectCandidate public API |
| CSmartObjectClaimHandleTag | SmartObjectClaimHandleTag public API |
| CSmartObjectClaimSnapshot | SmartObjectClaimSnapshot public API |
| CSmartObjectDefinition | SmartObjectDefinition public API |
| CSmartObjectExpirationReport | SmartObjectExpirationReport public API |
| CSmartObjectHandleTag | SmartObjectHandleTag public API |
| CSmartObjectQuery | SmartObjectQuery public API |
| CSmartObjectSlotDefinition | SmartObjectSlotDefinition public API |
| CSmartObjectWorld | Authoritative registry and lease manager for reservable world interactions |
| CStateDefinition | StateDefinition public API |
| CTaskArchive | Portable task state stored inside an NPC archive |
| CTaskContext | TaskContext public API |
| CTaskSpec | TaskSpec public API |
| CTickContext | Input time and work limits for one deterministic simulation update |
| CTickReport | TickReport public API |
| CTraceEvent | TraceEvent public API |
| CTransition | Transition public API |
| ►Nnpc_ai_editing | |
| CBehaviorCompileResult | Immutable compiled behavior graph with source revision |
| CBehaviorGraphDomain | Typed behavior-tree/decision-graph connection and compilation policy |
| CBehaviorInstruction | Deterministic behavior-graph instruction consumed by runtime adapters |
| ►Norders | |
| CCommandQueue | Generic priority order queue with no gameplay or entity semantics |
| CCommandQueueHandleTag | Owner tag for non-ECS order queue handles |
| COrder | One entity-agnostic command and its lifecycle metadata |
| COrderEvent | Deterministically sequenced order lifecycle event |
| COrderPayload | JSON-compatible key/value payload carried by an order |
| COrders | Script module factory for generic CommandQueue objects |
| ►Nos | |
| COS | OS module — host OS / hardware / wall-clock / clipboard / optional GPU info. Frame timing stays on Timer; this is host/environment queries |
| ►Nparticles | |
| CColorStop | Color gradient stop at normalized lifetime t in [0, 1] |
| CCurvePoint | Scalar curve point at normalized lifetime t in [0, 1] |
| CParticle | Single live particle (CPU simulation) |
| CParticleBudgetConfig | Global particle scalability controls shared by CPU and future GPU backends |
| CParticleConfigSystem | Polls bound config files (Resource.path) and hot-reloads when modtime changes. Returns number of emitters reloaded |
| CParticleCurve | Multi-point scalar curve sampled with linear interpolation between points. Empty curve means "use the legacy two-point linear fallback" |
| CParticleEffect | Runtime instance of a versioned, multi-emitter particle effect asset |
| CParticleEffectEventRoute | One authored cross-emitter event route inside a particle effect asset |
| CParticleEffectTimeline | Effect-level timeline controls (schema v2, optional on v1) |
| CParticleEffectTimelineCue | One effect-local timeline cue evaluated against the effect clock |
| ►CParticleEmitter | ECS emitter entity. Script configures components; ParticleSimSystem / ParticleRenderSystem drive per-frame update & draw |
| CAttach | Optional bone attachment. When enabled, syncAttach() writes Config.x/y (and optionally direction) from a live skeleton each frame. Particles remain 2D; 3D bone XYZ is projected via plane + scale |
| ►CConfig | Config public API |
| CBurst | Timed burst emission (fired once while the emitter is active) |
| CForceField | Radial attract/repel force fields (strength > 0 attract, < 0 repel) |
| CLightCfg | Emitter-level 2D light emission (pooled Light2D entities) |
| CParameterBinding | ParameterBinding public API |
| CSubEmitter | Script-linked sub-emitters (birth / death / collision triggers) |
| CDraw | |
| CGpuSim | Backend-owned GPU-resident simulation state and delayed CPU counters |
| CLights | Pooled Light2D entities driven by ParticleLightSystem (lights.enabled) |
| CResource | Bound config file for hot reload (empty path = unbound) |
| CSim | |
| CSkinSource | Optional skinned-mesh surface source. When enabled, newly spawned particles sample random (optionally bone-filtered) skinned vertices |
| CParticleEmitterPool | Soft pool of idle emitters for short-lived gameplay VFX |
| CParticleFrameStats | Counters from the most recent particle update and render pass |
| CParticleGradient | Multi-stop color gradient sampled with linear interpolation between stops. Stops are kept sorted by t. Empty gradient means "use the legacy colorStart/colorEnd two-point lerp" |
| CParticleLightSystem | Syncs pooled Light2D entities with alive particles (emitters with lights.enabled) |
| CParticleRenderSystem | Draws all visible ParticleEmitter entities via Graphics batch path |
| CParticles | Particles module — factory + script binding. Per-frame: scheduler step → config reload → ParticleSimSystem → ParticleRenderSystem. advance(SimulationStep) is the deterministic entry; update(float) remains a compatibility facade that explicitly consumes its Result. CPU particle integration is deterministic for fixed seed/tick within float integration tolerance; resident GPU integration is tolerance-bounded and may expose a backend-specific observable particle count |
| CParticleSimSystem | Advances all ParticleEmitter Sim components |
| CPcgMaterialSelector | Pcg-compatible particle texture palette that reserves candidate zero |
| ►Nparticles_editing | |
| CParticleGraphCompileResult | Validated particle configuration compiled from a module graph |
| CParticleGraphDomain | particles.emitter graph domain reflecting core emitter modules |
| CParticleGraphPreviewResult | Deterministic, revision-tagged particle preview estimate |
| CParticleGraphRuntimeBuilder | Optional bridge applying a compiled graph to a real ParticleEmitter |
| ►Nparticles_graphics_editing | |
| CIParticleOffscreenPresenter | Presentation boundary for an isolated, compiled particle preview |
| CParticleEmitterOffscreenPresenter | Real ParticleEmitter presenter with deterministic stepping and isolated drawing |
| CParticleOffscreenPreviewRequest | Revision-bound particle scrub preview request |
| CParticleOffscreenPreviewService | Compiles, budget-checks and rasterizes particle graph previews offscreen |
| ►Nphysics | Optional physics backend for vehicle mobility and body attach |
| ►Naction_adapter | |
| CActionCollisionIgnoreState | Owns temporary body-pair collision overrides projected from Action windows |
| CActionCollisionPair | Owning generation-qualified body pair selected for one collision channel |
| ►Nsoftbody | |
| CISoftBodyCollisionWorld | Narrow borrowed collision service consumed by the soft-body core |
| CSoftBodyContact | Backend-neutral contact returned to the volumetric solver |
| ►Ntrajectory | |
| CBoneColliderDefinition | Catalog entry that binds a sphere or capsule to named attachment points |
| CTrajectoryCollisionRuntime | Owner-thread authority for bone-bound collider catalogs and continuous sweeps |
| CTrajectoryFrame | Owning result of one deterministic trajectory advance. @cost Linear in the number of unique World3D cast hits emitted this frame |
| CTrajectoryHit | One confirmed World3D contact produced by a frame sweep |
| CTrajectorySample | World-space sample of one collider endpoint pair |
| CAcceleratorBackendProviderRegistration | Move-only lifetime token for one independently registered accelerator provider |
| CBody | 2D rigid body (Box2D) in pixel-space coordinates. Owned by a World; create shapes with newRectangleFixture/newCircleFixture |
| CBody3D | 3D rigid body (Box3D) in meter-space coordinates (+Y up by convention). Owned by a World3D; create primitive or convex-hull shapes with the new*Shape APIs |
| CBoneDetachEvent | One ordered detach event emitted during step |
| CBonePresentation | Presentation snapshot for one bone (world pose + proxy extents) |
| CBroadPhaseAabb3D | Fixed-capacity deterministic result of one AABB broad-phase query |
| CBroadPhaseHit3D | One generation-qualified shape returned by an owning broad-phase query |
| CCameraSphereHit3D | CameraSphereHit3D public API |
| CCapsuleMove3D | Owning result of continuous capsule movement |
| CCapsuleMovePolicy3D | Per-call capsule mover classification policy; never mutates persistent World3D settings |
| CCapsuleOverlap3D | Owning summary of a capsule overlap query |
| CCloth | Interactive 2D cloth — Verlet particles + distance constraints. Pixel space (same convention as Box2D World). Script-owned |
| CCloth3D | Interactive 3D cloth — Verlet particles + distance constraints. Meter space, +Y up, grid laid out in the XZ plane with the top row pinned |
| CClothContact3D | Result of a 3D point probe: deepest non-sensor shape within radius. Normal points from the shape toward the probed point (meters) |
| CClothGPU | GPU-accelerated 2D cloth — Verlet integration and distance-constraint relaxation run in a Vulkan compute shader; positions are read back each frame for drawing. Same pixel-space conventions and script API shape as Cloth |
| CClothModel | Reusable, validated cloth simulation asset |
| CClothModelDistanceConstraint | Precomputed rest-length constraint between two cloth particles |
| CClothModelFoldConstraint | Adjacent-triangle fold relationship around the shared edge (a,b) |
| CClothModelParticle | Immutable rest-space particle stored by a ClothModel |
| CClothModelTetherConstraint | Geodesic maximum-distance constraint from a particle to a fixed anchor |
| CClothModelTriangle | Triangle indices into a ClothModel particle array |
| CClusterBreakEvent | Emitted when a broken edge separates two different cook clusters |
| CContactRelay | |
| CDestruction | Optional physics satellite for Chaos-style geometry-collection destruction |
| CDestructionField | One volumetric influence applied to a geometry-collection instance |
| CDestructionFx | Optional presentation satellite for geometry-collection destruction |
| CDestructionStepBudget | Per-step production budgets (0 = unlimited) |
| CDestructionStepReceipt | Observable outcome of one checked step |
| CDistanceField3D | Regular 3D signed-distance grid for terrain and voxel collision queries. Negative samples are solid, positive samples are empty. Samples are stored at grid vertices and queried with trilinear interpolation |
| CFieldApplicationReceipt | Observable receipt for one checked field application |
| CFixture | 2D fixture: a shape attached to a Body with material + filter settings. Also carries a string tag used by contact events |
| CFluid2D | Interactive 2D particle fluid (double-density relaxation) in pixel space. Script-owned; independent of Box2D World |
| CFractureRecipe | Versioned cook recipe for Chaos-style pre-fracture (schema v1) |
| CGeometryCollectionAsset | Immutable cooked/authored geometry-collection asset |
| CGeometryCollectionBone | One pre-authored leaf bone (box collision proxy) inside a geometry collection |
| CGeometryCollectionEdge | One undirected structural edge with a strain break threshold |
| CGeometryCollectionInstance | Runtime owner of bone state, connection strain, and PhysicsLink bindings |
| ►CGeometryCollectionInstanceSnapshot | Persistent runtime snapshot for one geometry-collection instance |
| CBoneSnapshot | BoneSnapshot public API |
| CEdgeSnapshot | EdgeSnapshot public API |
| CGeometryCollectionRenderer | Presentation bridge for a borrowed geometry-collection instance |
| CIAcceleratorBackendProvider | Optional provider that creates an accelerator backend for domain state |
| CISimulationBackend | Minimal observable contract for physics simulation providers |
| CJoint2D | Script-facing Box2D joint owned by a World |
| CJoint3D | Script-facing Box3D joint owned by a World3D |
| CMechanism2D | Composed 2D mechanical assembly owned by a World |
| CMechanism3D | Composed mechanical assembly owned by a World3D |
| CPhysics | Physics module — Box2D (2D) + Box3D (3D) rigid bodies and SPH fluid. Script: physics <- eve.Physics(); world <- physics.newWorld(0, 900); world3 <- physics.newWorld3D(0, -9.8, 0); |
| CPhysicsArtifactCollider | Queryable CPU collider resource owned by the physics module |
| CPhysicsArtifactHandleTag | Owner tag for physics artifact runtime handles |
| ►CPhysicsArtifactProvider | Real physics-module provider for generated collider publication |
| ►CState | Owning runtime state for one published collider |
| CRuntimeCollider | |
| CPhysicsArtifactRayHit | Backend-neutral ray-query result used for parity tests |
| CPhysicsArtifactStage | Staged, owning Box3D construction for one provider mutation |
| CPhysicsBodyHandleTag | Tag for a process-local physics-body handle |
| CPhysicsJointHandleTag | Tag for a process-local physics-joint handle |
| CPhysicsJointLink | Generation-qualified relationship between a World3D and one joint |
| CPhysicsLink | Generation-qualified relationship between one world and one body |
| CPhysicsShapeHandleTag | Tag for a process-local physics-shape handle |
| CPhysicsShapeLink | Generation-qualified relationship between a World3D and one shape |
| CPhysicsVector3D | Allocation-free owning three-dimensional physics value |
| CPhysicsWorldHandleTag | Tag for a process-local physics-world handle |
| CQueryFilter3D | Query filter applied atomically for one owning query operation |
| CRayHit3D | Owning snapshot of the closest ray intersection |
| CRope | Optional physics satellite that owns rope construction, schema, and script bindings |
| ►CRope3D | Renderer-independent particle rope with XPBD stretch and bend constraints |
| CVec3 | Compact solver vector exposed only as a value type |
| CRopeColliderId | Stable identifier for a rope-owned analytic collider |
| CShape3D | 3D shape (box/sphere/capsule) attached to a Body3D with material settings. Created via Body3D::new*Shape; owned by the world |
| CSimulationBackendSelection | Result of choosing an optional accelerator or CPU alternate path |
| CSimulationObservation | Observable backend progress shared by CPU and accelerator providers |
| CSimulationSettings | Validated solver policy for one simulation step |
| CSoftBody3D | Volumetric particle soft body using overlapping shape-matching clusters |
| CSoftBody3DDefinition | Versioned, owning creation definition for one volumetric soft body |
| CSoftBody3DRenderer | Presentation-only renderer for a borrowed volumetric soft body |
| CSoftBodyModel | Backend-neutral, owning result of deterministic soft-body cooking |
| CSoftBodyModelCluster | An overlapping shape-matching cluster stored by particle index |
| CSoftBodyModelDefinition | Versioned authoring recipe used to cook a mesh-backed SoftBodyModel |
| CSoftBodyModelParticle | A particle stored in an immutable cooked soft-body model |
| CSoftBodyModelSurfaceBinding | A surface vertex bound directly to one cooked simulation particle |
| CTargetingLineOfSightAdapter | Read-only 3D physics implementation of sensing's LOS capability |
| CTerrainLoadGravityState | Caller-owned state for Pcg-style rigid-body activation after terrain loading |
| ►CWorld | Box2D world wrapper (2D physics) with pixel-space coordinates. Handles stepping, gravity, raycasts, AABB queries and contact/impact events |
| CClothContact | Result of a point probe: deepest non-sensor fixture within radius. Normal points from the shape toward the probed point (pixels) |
| CContactEvent | ContactEvent public API |
| CImpactEvent | |
| ►CWorld3D | Box3D rigid-body world. Script coordinates are meters (Box3D native), unlike 2D World which uses pixels + Physics.setMeter |
| CContactEvent | Begin/end event for two non-sensor shapes |
| CEventShape | Stable snapshot describing one side of a 3D collision event |
| CHitEvent | Significant collision containing world-space feedback data |
| CJointStressEvent | Joint whose solver force or torque exceeded a configured threshold |
| CTriggerEvent | Begin/end overlap event with an explicit sensor and visitor side |
| CWorldSnapshotAccess | |
| ►Nphysics_editing | |
| CIPhysicsColliderAssetResolver | Storage-neutral resolver for immutable collider geometry artifacts |
| CIPhysicsColliderRuntimeSink | Atomic runtime publication boundary for a complete collider candidate |
| CIPhysicsEditingFactory | Open capability for constructing collider authoring targets without editor type switches |
| CPhysicsColliderAssetGeometry | Validated CPU geometry resolved from an authored collider asset |
| CPhysicsColliderPublishingTarget | Candidate-first collider target whose commit/undo publishes to a live sink |
| CPhysicsColliderTarget | Serializable, backend-neutral 2D/3D collider authoring target |
| CPhysicsJointTarget | Serializable joint authoring target using stable body references |
| ►Nphysics_editor | |
| ►CPhysicsEditorModule | Composition adapter that publishes Physics editing capabilities into the live Editor host |
| CImpl | |
| ►Npixelworld | |
| CMaterialCatalog | Owning immutable material and reaction table used by one PixelWorld |
| CMaterialDefinition | Immutable validated properties for one catalog material |
| CMaterialPhaseRule | Data-driven phase transition evaluated after heat diffusion |
| CMaterialReactionRule | Deterministically ordered binary material reaction |
| CPixelCatalogReloadReceipt | Receipt for one transactional compatible material Catalog hot reload |
| CPixelCell | Compact authoritative state for one simulated world pixel |
| CPixelChunkApplyReceipt | Receipt for one all-or-nothing authoritative Chunk batch application |
| CPixelChunkBatch | Owning authoritative Chunk correction with source world metadata |
| CPixelChunkDiagnostic | Read-only per-Chunk simulation diagnostics for tooling and overlays |
| CPixelChunkRegion | Inclusive finite rectangle expressed in Chunk coordinates |
| CPixelChunkSnapshot | Owning, immutable projection of one authoritative simulation chunk |
| CPixelEditCommand | Owning replayable edit command. Sequence must be exactly previous + 1 |
| CPixelEditReceipt | Deterministic receipt for one atomically accepted edit command |
| CPixelFragment | Owning material bitmap detached atomically from a PixelWorld |
| CPixelFragmentRasterReceipt | Receipt for one all-or-nothing fragment rasterization |
| CPixelGeneratedChunkSummary | Deterministic diagnostics for one generated Chunk |
| CPixelMaterialStamp | Owning row-major material stamp applied after terrain and cave generation |
| CPixelRegion | Finite inclusive world-space rectangle used by structural queries |
| CPixelWorkScheduler | Synchronous executor for owning PixelWorld candidate buffers |
| ►CPixelWorld | Sparse, chunked, deterministic 2D falling-material world |
| CImpl | |
| ►CPixelWorldControlService | Main-thread-affine control surface shared by editor, CLI and MCP adapters |
| CImpl | |
| CPixelWorldGenerationOutput | Owning generated correction plus reproducibility evidence |
| CPixelWorldGenerationRequest | Versioned bounded request for deterministic biome and cave generation |
| CPixelWorldLink | Runtime identity of the world epoch from which a fragment was detached |
| CPixelWorldModule | Script-facing owner/factory for deterministic pixel material worlds |
| CPixelWorldPerformanceSample | One bounded process-local simulation performance sample |
| CPixelWorldStepReceipt | Receipt for an explicit bounded tooling step |
| CPixelWorldSummary | Stable summary of one live PixelWorld registered for local tooling |
| CStepStats | Counters produced by one deterministic simulation step |
| ►Npixelworld_editor | |
| CCatalogDraftReceipt | Draft mutation receipt used for UI reconciliation and optimistic publication |
| CMaterialCard | One renderer-neutral material card projected by the Catalog panel |
| CPixelWorldCatalogPanel | Dedicated visual material/reaction Catalog editor with transactional draft admission |
| CPixelWorldEditorModule | Script-facing owner for the dedicated PixelWorld Catalog panel |
| ►Npixelworld_graphics | |
| ►CPixelWorldAtlasRenderer | Render-thread-affine RGBA atlas projection of a rectangular PixelWorld region. @ownership The renderer owns only its CPU atlas; Graphics owns the Texture handle. @lifetime A renderer using a texture must be destroyed before its Graphics backend |
| CImpl | |
| CPixelWorldGraphics | Optional rendering satellite for the backend-neutral PixelWorld module |
| ►Npixelworld_physics | |
| CFragmentBodyConfig | Policy for dynamic fragment fixture creation and terrain settlement |
| CFragmentCollisionRect | One deterministic axis-aligned fixture produced from a fragment bitmap |
| CFragmentSettleReceipt | Receipt for one checked fragment-body settlement poll |
| CPixelFragmentBody | Owning detached bitmap plus a non-owning, stale-safe dynamic body link |
| ►CPixelTerrainCollisionCache | Incremental static collision projection of authoritative PixelWorld chunks |
| CImpl | |
| CPixelTerrainContact | Deterministic contact returned by an authoritative terrain probe or sweep |
| CPixelWorldPhysics | Script-facing owner for PixelWorld-to-Box2D terrain projection |
| CTerrainCollisionContour | One simplified local-space boundary contour generated for a terrain Chunk |
| CTerrainCollisionSyncReceipt | Counters for one transactional dirty-Chunk terrain collision sync |
| ►Npixelworld_replay | |
| CPixelChunkDigest | Canonical content digest for one authoritative PixelWorld Chunk |
| CPixelReplayCheckpoint | Periodic replay checkpoint containing world and per-Chunk diagnostics |
| CPixelReplayDivergence | First canonical mismatch found while replaying a log |
| CPixelReplayEntry | One deterministic edit admitted immediately before its simulation Tick |
| CPixelReplayLog | Owning command log and periodic checkpoint projection for PixelWorld |
| CPixelReplayReceipt | Receipt from deterministic replay through an exact target Tick |
| ►Npixelworld_streaming | |
| CPixelChunkAckReceipt | Counters returned after accepting a cumulative ACK |
| CPixelChunkReceiveReceipt | Receiver outcome after one possibly duplicate or out-of-order part |
| CPixelChunkStreamCursor | Stateful revision cursor that projects one PixelWorld interest region |
| CPixelChunkStreamUpdate | One interest-stream update suitable for persistence or network transport |
| CPixelChunkTransferAck | Cumulative application ACK proving transfers were committed to replica authority |
| CPixelChunkTransferPart | One independently retransmittable part of an atomic Chunk transfer |
| CPixelChunkTransportConfig | Bounded application-level reliability policy layered over any byte transport |
| CReliablePixelChunkReceiver | Ordered atomic receiver with duplicate suppression and bounded out-of-order buffering |
| CReliablePixelChunkSender | Reliable sender retaining owning transfer parts and tombstones until application ACK |
| ►Npixelworld_thread | |
| CJobSystemPixelScheduler | Synchronous PixelWorld candidate scheduler backed by engine JobSystem |
| ►Nplatform_event | |
| ►Nsdl | |
| CEvent | Event public API |
| CIPlatformEventSink | EVENGINE_API_FOUNDATION public API |
| CMessage | A named event carrying an ordered list of Variant payloads. Pushed messages are heap-allocated; the queue owns them until polled, after which the caller is responsible for deleting them |
| CPlatformEvent | EVENGINE_API_FOUNDATION public API |
| CVariant | Variant public API |
| ►Nplugins | |
| CPlugins | 加载导出 eve_plugin_init 的原生动态库（dll / so / dylib）。 |
| ►Npolicyregistry | |
| CPolicyDescriptor | Discoverable policy description without an executable callback |
| CPolicyEvent | Deterministically sequenced policy registry mutation event |
| CPolicyHandle | Generation-qualified policy handle used to detect replacement or removal |
| CPolicyRegistry | Deterministic registry for discoverable, non-executable policy descriptions |
| CPolicyRegistryModule | Script module factory for independent policy registries |
| ►Nprocgen | |
| ►Ngridgraph | |
| CGenerateSettings | GenerateSettings public API |
| ►Nprototype_detail | |
| CVec3 | Vec3 public API |
| ►Nroad | |
| CRoadBakeOptions | Options for baking a road network into mesh + navigation overlays |
| CRoadBakeResult | Owning bake result: mesh, overlays and generic decoration placement points |
| CRoadControlPoint | One authored control point on a road centerline (world space, Y-up) |
| CRoadEdge | Directed centerline edge with optional reverse lanes |
| CRoadEdgeSplitResult | Stable identities produced by one atomic edge split |
| CRoadLaneConnection | One legal lane-to-lane connection inside a junction |
| CRoadNetwork | Owning directed road graph with lane connectivity |
| CRoadNode | Junction node owned by a road network |
| CRoadOverlay | Owning bake-time overlay snapshot (no pointers into the network) |
| CRoadPolyline | One renderer-neutral polyline chunk for navigation / marking overlays |
| CRoadProfile | Owning open profile polyline for one edge style and lane layout |
| CRoadProfilePoint | One 2D profile sample in the edge local (side, up) plane |
| CRoadStyle | Cross-section and structural style for one road edge |
| CRoadTerrainConformOptions | World/grid mapping and bounded blending settings for road-to-terrain conformance |
| CRoadTerrainConformReceipt | Exact changed samples needed to safely restore one road terrain conformance. @cost Storage, copy and move-destruction work are linear in the number of changed samples |
| ►Nurban | |
| CBoundaryPosition | Where a point sits on the polygon boundary: edge edgeIndex at parameter t in [0,1] |
| CBoundarySample | A boundary sample used for field constraints / candidate seeds |
| CGraphEdge | Undirected edge of the parcel corner graph |
| CParcel | One parcel: a CCW ring of indices into UrbanLayout::corners |
| CSplitCandidate | Candidate splitting lines for a parcel (paper Section 4.1). Each candidate is a polyline from one boundary point to another, strictly inside otherwise, and verified to split the parcel into two simple polygons |
| CStreet | A street decomposed from the street network graph: consecutive street edges whose included angle is larger than 135° belong to the same street |
| ►CUrbanGenerator | Hierarchical co-generation of parcels and streets (paper Section 4) plus the global geometric optimization (paper Section 5) |
| CGenState | |
| CUrbanLayout | Structured urban layout produced by the hierarchical co-generation (paper Section 4) plus the geometric optimization (paper Section 5) |
| CUrbanOptions | All user-facing controls for the urban generator. Defaults follow the paper (λ=0.3/0.5/0.2, γ=0.75/0.25, τ=0.5, I/L-shaped access, cul-de-sac avoidance on) |
| CVec2 | Minimal 2D vector used by the urban layout algorithms (paper coordinates) |
| CArtifactPart | One typed, role-named child product inside a composite artifact |
| CArtifactPublisher | Coordinates adapter preparation and atomic CPU-store publication |
| CArtifactPublishReceipt | Compatibility receipt retaining procgen ArtifactId at this boundary |
| CArtifactSnapshotContext | Snapshot context supplied by the caller; time and hashing are injected |
| CArtifactStore | In-memory owner and publisher for generated artifacts |
| CArtifactStoreStage | |
| CAttributeTable | Schema-bearing column store aligned with a PointSet's point rows |
| CBiomeAssetRule | One weighted asset entry in a procedural biome layer |
| CBiomeLayerRule | One spatially-defined biome layer and its asset table |
| CBiomeRules | Data-driven biome distribution rules compatible with PointGraph and scene batches |
| CBounds | Axis-aligned bounds in the artifact's declared world coordinate space |
| CBuildClusterChange | One cache mutation emitted by an incremental cluster rebuild |
| CBuildKey | Stable key for deterministic-equivalent generation inputs |
| CBuildLayerArtifact | One named build-layer artifact in configured execution order |
| CBuildLayerExecution | Immutable-by-convention result of one complete build-stack execution |
| CBuildLayerRegion | Half-open grid and world-space bounds used for one incremental cluster build |
| CBuildLayerStack | Ordered, versioned executor for procedural tile and object build layers |
| CCaveAbrasionInput | Inputs for sediment-laden flood abrasion of a cave passage |
| CCaveAbrasionSample | Near-bed abrasion, sediment cover, and coherent vortex-cell response |
| CCaveBiogenicCorrosionInput | CaveBiogenicCorrosionInput public API |
| CCaveBiogenicCorrosionSample | CaveBiogenicCorrosionSample public API |
| CCaveBoundaryClosure | CaveBoundaryClosure public API |
| CCaveBreakdownBlock | CaveBreakdownBlock public API |
| CCaveBreakdownChamber | CaveBreakdownChamber public API |
| CCaveBreakdownEvent | CaveBreakdownEvent public API |
| CCaveBreakdownSet | CaveBreakdownSet public API |
| CCaveCondensationResult | CaveCondensationResult public API |
| CCaveConstrictionScourSample | Local plunging-flow scour and exit-widening response |
| CCaveConstrictionScourSite | One flow-driven constriction-pool-widening sequence derived from passage geometry |
| CCaveDetachmentResult | CaveDetachmentResult public API |
| CCaveDifferentialErosionInput | CaveDifferentialErosionInput public API |
| CCaveDifferentialErosionSample | CaveDifferentialErosionSample public API |
| CCaveFacetInput | CaveFacetInput public API |
| CCaveFacetSample | CaveFacetSample public API |
| CCaveFieldPoint | CaveFieldPoint public API |
| CCaveFracture | One deterministic structural fracture plane in normalized cave space |
| CCaveFractureChannelizationInput | Inputs for aperture-driven reactive channelization within a cave fracture network |
| CCaveFractureChannelizationSample | Observable local state of aperture-flow-dissolution feedback |
| CCaveFractureInput | Inputs for heterogeneous, stress-controlled fracture dissolution |
| CCaveFractureSample | Observable local state of a sampled dissolving fracture |
| CCaveHydrologyBranch | CaveHydrologyBranch public API |
| CCaveHydrologyPoint | CaveHydrologyPoint public API |
| CCaveHydrologyVec3 | CaveHydrologyVec3 public API |
| CCaveHydrologyWeights | CaveHydrologyWeights public API |
| CCaveKarrenInput | Inputs for fracture-guided dissolution grooves on an exposed cave-stream bed |
| CCaveKarrenSample | Observable stream-bed karren response at one cave-space sample |
| CCaveKnickpointSample | Local vertical drilling and headwall-undercut response at a cave-stream knickpoint |
| CCaveKnickpointSite | One slope-break-driven cave-stream knickpoint and downstream plunge pool |
| CCaveLithologyInput | Inputs for lithology-selective bedding and stylolite dissolution |
| CCaveLithologySample | Local bed resistance, stylolite exposure, and selective retreat |
| CCaveMicrostructureSample | CaveMicrostructureSample public API |
| CCaveMineralArmoringInput | Inputs for secondary-mineral shielding of a dissolving cave wall |
| CCaveMineralArmoringSample | Observable local state of a retained secondary-mineral coating |
| CCaveMixingCorrosionSample | Local corrosion strength and the contributing mixing-water potential |
| CCaveMixingSite | One chemistry-weighted branch-to-trunk mixing site |
| CCaveObstacleScourSample | Local upstream horseshoe and downstream wake erosion response |
| CCaveObstacleScourSite | One landed breakdown block coupled to a horseshoe-vortex and wake scour footprint |
| CCavePassageFrame | CavePassageFrame public API |
| CCavePluckingInput | Inputs for flood plucking of fracture-bounded cave-floor blocks |
| CCavePluckingSample | Local fracture predisposition, hydraulic threshold, and block removal response |
| CCavePotholeSample | Local primary and compound pothole erosion response |
| CCavePotholeSite | One fracture-seeded, sediment-driven eddy pothole on a cave-stream bed |
| CCaveReactivePatchinessResult | Diagnostics from spatially correlated heterogeneous cave-wall dissolution |
| CCaveResampledField | CaveResampledField public API |
| CCaveRoughnessInput | Inputs for deterministic, band-limited cave-wall roughness |
| CCaveRoughnessSample | Multi-scale wall relief and its separated spatial-frequency bands |
| CCaveRoughnessTransferInput | Inputs for rough-wall control of local dissolution mass transfer |
| CCaveRoughnessTransferSample | Bounded mass-transfer response of an exposed ridge or sheltered recess |
| CCaveScallopHistoryInput | Inputs for a younger, spatially bounded cave-scallop erosion stage |
| CCaveScallopHistorySample | Observable combination of preserved older and younger scallop generations |
| CCaveScallopInput | CaveScallopInput public API |
| CCaveScallopSample | CaveScallopSample public API |
| CCaveSedimentBar | CaveSedimentBar public API |
| CCaveSedimentClast | CaveSedimentClast public API |
| CCaveSedimentPathPoint | CaveSedimentPathPoint public API |
| CCaveSedimentSet | CaveSedimentSet public API |
| CCaveSurfaceAnchor | CaveSurfaceAnchor public API |
| CCaveSurfaceEvolutionResult | CaveSurfaceEvolutionResult public API |
| CCaveSurfaceReactivityResult | Diagnostics from geometry-controlled cave-surface dissolution |
| CCaveVerticalSpan | CaveVerticalSpan public API |
| CCaveWaterTableInput | Inputs for a staged epiphreatic water-table corrosion belt |
| CCaveWaterTableSample | Local staged water-table corrosion and the dominant historical level |
| CCaveWetnessRefinement | CaveWetnessRefinement public API |
| CClimateMap | ClimateMap public API |
| ►CCloudField | Deterministic, seamlessly-tiling, time-animated procedural cloud field |
| CParams | Params public API |
| ►CCloudShadow | Cloud shadows cast onto the ground plane |
| CParams | Params public API |
| CCollider | Backend-neutral collider product, normally a triangle mesh or hull |
| ►CColorRamp | Piecewise-linear color ramp in t∈[0,1], with optional hard banding |
| CStop | Stop public API |
| CCompositeArtifact | A coherent set of products published from one deterministic build |
| CDecodedTerrainFile | Height field decoded from a persisted terrain file |
| CDynamicMeshUvPaintSession | Integrates dynamic-mesh hit mapping with the canonical image UV-paint session |
| CFluvialErosionSettings | FluvialErosionSettings public API |
| CFoliageClusterDesc | Recipe for one stylized leaf cluster ("foliage card bundle") |
| CGeneratedArtifact | Complete immutable-once-published artifact record |
| CGeneratorRegistry | Registry for executable generators and their reflection metadata |
| CGeometryStroke | Runtime/editor-neutral session that turns an input trail into mesh geometry |
| CGeometryStrokePoint | One input sample owned by a procedural geometry stroke |
| CGrid2D | Intermediate 2D generation result. cells store semantic ids (see Semantic.h), not tile GIDs — convert via Palette when applying to a TileLayer |
| CGridGraph | Deterministic data-flow graph for grid generation and explicit grid-to-point composition |
| CGridObject | Named rectangle or asset placement emitted by a procedural generator |
| CGtsColorMapSettings | GTS terrain colormap controls from GTSColorMapSettings |
| CGtsDetailNormalSettings | GTS near/far detail-normal controls from GTSDetailSettings |
| CGtsGeologicalSettings | GTS height-axis geological overlay controls from GTSGeoSettings |
| ►CGtsHeightBlendSet | Owning ordered GTS layer-height rasters and their alpha-channel transforms |
| ►CImpl | |
| CLayer | |
| CGtsMacroVariationSettings | GTS three-scale macro color variation controls from GTSVariationSettings |
| CGtsMeshSimplificationOptions | GTS mesh simplification controls supported by MeshBuild streams |
| CGtsMeshSplitResult | Owned row-major result of a GTS X/Z plane split |
| CGtsMeshSplitTile | One row-major GTS mesh cell and the world offset restoring its source position |
| ►CGtsPackedLayerSet | Owning ordered GTS packed albedo/height and normal/AO/smoothness texture layers |
| ►CImpl | |
| CLayer | |
| CGtsPackedLayerSettings | One GTS packed texture-array layer's planar sampling and material controls |
| CGtsRainSurfaceSettings | GTS rain albedo controls copied from GTSRainSettings |
| CGtsSnowSurfaceSettings | GTS snow albedo controls copied from GTSSnowSettings |
| CGtsTerrainExportLodSettings | Complete native counterpart of one GTSExportTerrainLODSettings record |
| CGtsTerrainExportSettings | Schema-versioned source/impostor terrain export profile |
| CGtsTerrainExportWorkflow | Validated execution plan compiled from top-level Pcg terrain export controls |
| CGtsTerrainLodAssetEntry | Deterministic native export identity for one GTS tile LOD mesh |
| CGtsTerrainLodAssetPlan | Owned script-friendly GTS terrain LOD export manifest |
| CGtsTerrainLodLevelSettings | Configuration for one sequential GTS terrain mesh LOD |
| ►CGtsTerrainLodRuntime | Transactional runtime owner for one row-major batch of GTS terrain tile renderables |
| CImpl | |
| CGtsTerrainLodSet | Owned result of the GTS split-and-sequential-simplify pipeline |
| CGtsTerrainLodTile | One split terrain tile and all of its local-space LOD meshes |
| CGtsTerrainMeshSettings | Schema-versioned native counterpart of GTSMeshSettings |
| CHeightmap | In-memory terrain heightmap: a dense float grid (row-major, index = y * width + x) materialized from a TerrainSampler or filled by hand |
| CHydraulicErosionSettings | HydraulicErosionSettings public API |
| CHydrologyMap | HydrologyMap public API |
| CImageData | Small owning image product; raw pixels stay out of JSON metadata |
| CIncrementalBuildDelta | Ordered changes required to synchronize a scene-side cluster cache |
| CIncrementalBuildExecutor | Derived cluster cache that incrementally executes a BuildLayerStack |
| CITerrainArchiveSource | Immutable random-access byte source for an EVTR archive |
| CLSystem | General stochastic bracketed L-system engine |
| CLSystemResult | Full result of expanding an L-system grammar and tracing the turtle |
| CLSystemSegment | One drawn segment produced by an L-system turtle |
| CMemoryTerrainArchiveSource | Owning in-memory EVTR source used by compatibility callers and tests |
| CMeshAdhereLive | Real-time dynamic fusion session: source A sticks to surface B with adjustable params |
| CMeshBuild | CPU triangle mesh from procedural mesh recipes (e.g. marching cubes). Positions/normals are xyz-packed; uvs are st-packed; indices are triangles |
| CMeshContactBlendParams | Parameters for contact-band edge and material fusion |
| CMeshDeformationSession | Stateful CPU sculpting session with explicit bake, restore, and undo semantics |
| CMeshGraph | Typed procedural mesh graph composing grid, point and topology domains |
| CMeshMergePlan | Authoring plan for commit-style static mesh merge |
| CMeshModifierGraph | Deterministic CPU data-flow graph for procedural mesh deformation and composition |
| CMeshModifierNodeMetric | Per-node telemetry captured by the latest successful mesh graph execution |
| CMeshRecipeRegistry | EVENGINE_API_DOMAINS public API |
| CMeshSurfaceUv | UV coordinate resolved from a dynamic-mesh triangle hit |
| CMeshVertexSelectionCenter | Value-only center of the current runtime vertex selection |
| CModuleAssemblyConstraints | Configurable limits shared by automatic modular-map generators |
| CModuleAssemblyPlan | Deterministic owner of a validated modular assembly plan |
| CModuleConnector | A typed connection exposed on one occupied cell edge |
| CModuleDefinition | Immutable footprint and connection contract for one modular asset |
| CModulePlacement | World-grid placement accepted by a ModuleAssemblyPlan |
| CNoiseField | Deterministic value-noise helpers for pixel textures. When periodX/periodY > 0, lattice wraps for seamless tiling |
| CObjectBuildLayer | Deterministic TileWorldCreator-style object build layer |
| CObjectTransformRange | Random transform interval used by one object build rule |
| COutputSpec | Configurable generation sink. target: "grid" | "tilelayer" | "json" |
| CPaletteTable | Named palette: semantic name -> tile GID. Unmapped semantics become GID 0 |
| CParamDescriptor | UI-independent metadata for one procedural recipe parameter |
| CParams | Owning, typed generation parameters |
| CPbrParams | PBR surface defaults for a generated material. Every map in a PBR set is derived from the same displacement field (see TextureRecipeDef) |
| CPbrRecipeRegistry | EVENGINE_API_DOMAINS public API |
| CPbrTextureSet | Full metallic-roughness PBR map set. All maps are caller-owned; call destroy() (or delete each pointer) when done. Maps are derived from one shared displacement field so albedo, normal, height, roughness, metallic and AO line up pixel-for-pixel |
| CPcgBiomeController | Native runtime state for Pcg BiomeController placement and automatic terrain loading bounds |
| CPcgBiomeLoadingBounds | Axis-aligned world-space loading bounds owned by one biome controller |
| CPcgFrameRateManager | Caller-owned deterministic Pcg frame-rate sampling and quality policy |
| CPcgMeshCombinePlan | Owned ordered input plan for Pcg static MeshCombiner |
| ►CPcgMeshLodBackup | Caller-owned transactional backup of one Renderable3D renderer before Pcg LOD replacement |
| CImpl | |
| CPcgMeshLodLevel | One UnityMeshSimplifierPcg LOD level translated to native mesh settings |
| CPcgMeshLodProfile | Mutable value profile for at most four native renderer LOD levels |
| CPcgMeshLodRendererState | Pcg/Unity renderer policies retained per generated mesh LOD |
| CPcgMeshLodSet | Owned generic mesh LOD output generated with Pcg's independent-per-level policy |
| CPcgMeshTransform | Row-major affine matrix used by Pcg's root-relative static mesh combination |
| CPcgRuntimeStamper | Native orchestration of Pcg RuntimeStamper's load, flatten, fit, mask, and stamp sequence |
| CPcgSpawnProgress | Caller-owned, deterministic progress state corresponding to Pcg SpawnProgressBar. @thread Spawning thread only |
| CPcgTaskQueue | Deterministic, callback-free port of PcgTask's delayed task queue |
| CPcgTerrainChange | One copied terrain identity and its change kind |
| CPcgTerrainPhotoModeAuthority | Explicit photo-mode owner for runtime terrain quality selection |
| CPcgTerrainPhotoModeState | Pcg terrain quality state used by terrain mesh, material and detail render callers |
| CPcgTerrainQualityPreset | Terrain quality values selected by Pcg's six-level frame-rate manager |
| CPcgTerrainStreamingAuthority | Explicit PhotoMode owner for a borrowed terrain streaming cache. @lifetime The target cache must outlive this authority or be detached with setTarget(nullptr, scale). @thread Game thread only; callbacks and scripts are not invoked |
| CPcgTerrainStreamingState | Pcg world-space terrain streaming ranges and their chunk-space projection |
| CPcgTerrainWatcher | Deterministic, caller-driven equivalent of PcgTerrainWatcher's hierarchy diff |
| CPcgTreeManager | Caller-owned world-space tree index matching Pcg TreeManager's rectangular queries. @ownership Copies positions and prototype indices; PointSet inputs are borrowed only during calls. @thread Caller-thread affine; methods invoke no callbacks and read no hidden time or RNG |
| ►CPointCompute | Backend-neutral GPU kernels used by PointGraph with deterministic CPU fallback |
| CImpl | |
| CTransform | One transform operation in a fused point-compute dispatch |
| CPointDelta | Transactional identity-based change set between two point snapshots |
| CPointGraph | EVENGINE_API_DOMAINS public API |
| CPointGraphColumnInfo | A data-flow graph for attributed procedural points |
| CPointGraphInspectReport | Snapshot of one node output for editor Attribute/Inspect panels |
| CPointGraphNodeMetric | Per-node execution information from the most recent graph run |
| CPointSet | Script-friendly collection of attributed 3D samples |
| ►CProcgen | Procedural generation module. Phase A: runtime maps (semantic Grid2D → TileLayer). Phase B: runtime textures (ImageData / Texture). Phase C (partial): mesh recipes (Marching Cubes → MeshBuild / Mesh). Script: procgen <- eve.Procgen(); |
| COwnershipState | |
| CProcgenAttributeVector | Compact three-component value used by typed procedural metadata |
| CProcgenBiomeRulesHandleTag | Handle domain for module-owned biome rules |
| CProcgenCachedStage | One committed PointSet cache entry for a named script pipeline stage |
| CProcgenCellRequest | One immutable runtime-generation cell request returned to script |
| CProcgenCloudFieldHandleTag | Handle domain for module-owned cloud fields |
| CProcgenCloudShadowHandleTag | Handle domain for module-owned cloud shadow fields |
| CProcgenContext | Staging area for one atomic rebuild of a named procedural system |
| CProcgenContextHandleTag | Handle domain for module-owned procedural rebuild contexts |
| CProcgenDynamicMeshUvPaintSessionHandleTag | Handle domain for module-owned dynamic-mesh UV paint sessions |
| CProcgenGenerationCompletion | Owning worker result returned to a RuntimeGeneration scheduler |
| CProcgenGenerationJob | Copyable generation input issued by one RuntimeGeneration scheduler |
| CProcgenGridGraphHandleTag | Handle domain for module-owned grid graphs |
| CProcgenGridHandleTag | Handle domain for module-owned procedural grids |
| CProcgenHeightmapHandleTag | Handle domain for module-owned heightmaps |
| CProcgenImageHandleTag | Handle domain for module-owned generated images |
| CProcgenLSystemHandleTag | Handle domain for module-owned L-system engines |
| CProcgenMeshBuildHandleTag | Handle domain for module-owned CPU mesh builds |
| CProcgenMeshDeformationSessionHandleTag | Handle domain for module-owned interactive mesh deformation sessions |
| CProcgenMeshGraphHandleTag | Handle domain for module-owned mesh graphs |
| CProcgenMeshModifierGraphHandleTag | Handle domain for module-owned mesh modifier graphs |
| CProcgenNormalImageHandleTag | Handle domain for module-owned generated normal images |
| CProcgenOpenTrace | One currently running automatic stage timer |
| CProcgenOutputHandleTag | Handle domain for module-owned output specifications |
| CProcgenParamsHandleTag | Handle domain for module-owned procedural parameter objects |
| CProcgenPbrMaterialHandleTag | Handle domain for module-owned PBR material sets |
| CProcgenPoint | One deterministic sample used by script-first procedural pipelines |
| CProcgenPointGraphHandleTag | Handle domain for module-owned point graphs |
| CProcgenPointSetHandleTag | Handle domain for module-owned point-set intermediates |
| CProcgenRuntimeGenerationHandleTag | Handle domain for module-owned runtime-generation schedulers |
| CProcgenShapeGrammarHandleTag | Handle domain for module-owned shape grammars |
| CProcgenSpatialDataHandleTag | Handle domain for module-owned spatial data |
| CProcgenSplinePathHandleTag | Handle domain for module-owned 3D spline paths |
| CProcgenStageMetric | One named diagnostic step recorded by a script-first generation transaction |
| CProcgenSystemSnapshot | Immutable committed snapshot retained by Procgen across script reloads |
| CProcgenTerrainSamplerHandleTag | Handle domain for module-owned terrain samplers |
| CPrototypePieceDescriptor | Metadata for one centered, Y-up module in the built-in prototype construction kit |
| CPrototypeTextureDescriptor | Metadata for one development/prototype texture pattern |
| CRecipeDescriptor | Complete metadata and parameter schema shared by every procgen recipe family |
| CRgba8 | Rgba8 public API |
| CRuntimeGeneration | View-driven partition and hierarchical procedural generation scheduler |
| CScriptProcgenContext | Internal Squirrel proxy for a module-owned rebuild context handle |
| CScriptProcgenGrid | Internal Squirrel proxy for a module-owned Grid handle |
| CScriptProcgenParams | Internal Squirrel proxy for a module-owned Params handle |
| CShapeGrammar | Module-based shape grammar expanded continuously along a 3D polyline |
| CShapeModuleVariant | One weighted asset variant represented by a shape-grammar symbol |
| CSpatialBounds | Axis-aligned bounds shared by all procedural spatial data types |
| CSpatialData | Queryable spatial input for procedural pipelines |
| CSplineDistribution | Owning uniformly distributed spline samples for instancing |
| CSplineFrameSample | Evaluated spline sample with an orthonormal transported cross-section frame |
| CSplinePath | Owning multi-segment 3D spline with deterministic bounded sampling |
| CSplinePoint | One spline anchor with incoming and outgoing handle offsets |
| CSplinePolyline | Owning sampled polyline for renderer-neutral runtime visualization adapters |
| CSplineProfile | Owning cross-section snapshot used by mesh.splineExtrude |
| CSplineProfilePoint | One vertex of an owning two-dimensional spline extrusion profile |
| CSplineSample | Evaluated spline position and normalized tangent |
| CTerrainAffectedPixels | Integer rectangles mapping one tile into the shared operation raster |
| CTerrainAsset | Versioned, random-access terrain archive |
| ►CTerrainBakedMaskCache | Own Pcg-style per-terrain baked scalar masks keyed by stable terrain and mask identities. Entries contain copied CPU rasters. Scene objects, providers, GPU resources, callbacks, clocks and RNG are not retained |
| ►CImpl | |
| CEntry | |
| CTerrainBands | TerrainBands public API |
| CTerrainBiomePreset | Own an ordered Pcg-style biome preset made from independent spawner plans. Entries and plans are copied at insertion. Compilation namespaces each rule by its stable entry ID, preserving order while allowing different spawners to use the same local rule ID. No scene pointer or asset object is held |
| CTerrainBiomeSpawnerEntry | One owned Pcg BiomePreset spawner entry with its two activation scopes |
| CTerrainBrushBlendSettings | Paint-context affine UV mappings, evaluated at destination pixel centers |
| CTerrainChunkData | Decoded terrain chunk containing all baked runtime layers |
| CTerrainChunkEntry | Metadata for one independently compressed chunk in an EVTR archive |
| ►CTerrainCollisionMaskStack | Own an ordered Pcg-style collision-mask stack made from caller-baked scalar rasters. Geometry queries and cache invalidation remain with the caller; every added raster is copied and no scene object, callback, renderer resource, clock or RNG survives a call |
| ►CImpl | |
| CLayer | |
| CTerrainConcavitySettings | Concavity source controls; featureSize is in height texels, concavity is signed |
| CTerrainCurvatureSettings | Radial curvature controls; radius is UV distance, worldUnits scales signed height-minus-blur |
| CTerrainCurveTextureReceipt | Range and write count returned by Pcg AnimationCurve texture baking |
| ►CTerrainDetailLayer | Owned integer terrain-detail layer, independent of graphics and resource registries. Each instance is an independent owning value; explicit copies deep-copy all counts for transaction snapshots. Caller serializes access on its owning thread. Every operation evaluates privately and publishes once; no callback, borrowed raster or mutable view survives a call. Each apply owns a named detail-thinning RNG stream initialized by its explicit signed seed. Replay uses same-build float arithmetic, X-major iteration and conditional source RNG draws. This layer covers one complete aligned terrain and owns independent density rasters keyed by stable resource namespace. Multi-terrain windows and renderer instancing remain in their existing domain owners |
| CImpl | |
| CTerrainDetailPlacementSettings | Explicit native placement domain and resource for a terrain detail layer |
| CTerrainDetailSettings | Effective detail rule settings; density is rule density times global spawn density |
| CTerrainDetailSpawnRule | One owned Pcg-style detail spawn rule |
| CTerrainDetailTile | Borrowed mutable detail layer participating in one synchronous world operation |
| CTerrainDistanceMaskSettings | Value-only UV transform; distances are relative to the target raster, rotation in radians |
| CTerrainErosionMap | Per-cell diagnostic outputs produced by an erosion stage |
| ►CTerrainGenerationSession | Owned in-memory terrain operation session; records native stamps, scalar effects and erosion. Owns baseline, current terrain, sediment, water and immutable copies of operation inputs. No borrowed raster, scene object, script callback or GPU resource survives a call. Replays use the same CPU kernels and inputs in order; determinism is same-build floating arithmetic. All access is serialized by the caller on its owning thread. History mutations and terrain, sediment and all water channels publish together after successful evaluation; allocation failure preserves all state. Snapshots are copies, never a second writable view of the authoritative terrain. Versioned snapshots retain the baseline, every owned command, enabled flags, cursor and access policy. Asynchronous worker tickets and a generic gameplay object model are not introduced |
| CCommand | |
| CImpl | |
| CTerrainHeightMixSettings | Mix-height scalar controls; delta scale is maximum-minimum, independent of clipping bounds. Defaults use Pcg's scalar input range [0,1] and packed terrain output [0,0.5]. World-height callers must provide consistent delta scale and clipping bounds |
| CTerrainHeightStitchSettings | Pcg terrain-height seam controls; maxDifference is retained for source-profile compatibility |
| CTerrainHeightTile | Borrowed mutable height tile participating in one synchronous world operation |
| CTerrainImageMaskSettings | Image UV transform and color-selection settings, rotation in radians |
| CTerrainLakeMeshBuilder | Builds flat water-surface cells for Priority-Flood depressions |
| CTerrainLakeMeshSettings | TerrainLakeMeshSettings public API |
| CTerrainLayers | Script-friendly ownership wrapper for baked hydrology and climate layers |
| CTerrainLegacyDistributedErosionSettings | Thresholds and iteration count for Pcg HeightMap.Erode's synchronous cardinal transport |
| CTerrainLegacyHydraulicSettings | Controls Pcg HeightMap.ErodeHydraulic's legacy CPU erosion loop |
| CTerrainLegacySteepestErosionSettings | Thresholds and iteration count for Pcg HeightMap.ErodeThermal's in-place steepest transport |
| CTerrainLodSelector | Screen-space-error LOD choice based on measured heightfield deviation |
| CTerrainMeshBuilder | Builds LOD heightfield chunks with stable normals, skirts, and biome splat weights |
| CTerrainMeshChunk | One renderable heightfield chunk plus four ecological material weights |
| CTerrainMeshSettings | TerrainMeshSettings public API |
| CTerrainModifierStampSpawnRule | One owned Pcg TerrainModifierStamp rule, including both ordered mask domains |
| ►CTerrainMultiDetailWorkspace | Owning script-safe multi-terrain detail transaction workspace. Input layers are copied on insertion. Operations, reports and all-layer undo snapshots publish by one owner-thread swap; no borrowed raster or callback survives a call. The explicit seed creates one deterministic stream per apply |
| ►CImpl | |
| CSnapshot | |
| CTile | |
| ►CTerrainMultiObjectWorkspace | Owning transactional multi-terrain object workspace with undo and redo snapshots |
| ►CImpl | |
| CSnapshot | |
| CTile | |
| ►CTerrainMultiSplatWorkspace | Owning script-safe multi-terrain splat transaction and all-tile undo history. Input maps are copied. Paint, report and history publish through one owner-thread swap; no external references, callbacks, renderer resources, RNG or time survive a call |
| ►CImpl | |
| CSnapshot | |
| CTile | |
| CTerrainMultiTileReport | Completed multi-tile stamp statistics and Pcg-compatible affected-pixel mappings |
| ►CTerrainMultiTileWorkspace | Owning script-safe collection of height tiles with atomic multi-tile operations. Tiles are copied on insertion and never retain caller rasters. The workspace is one mutable owner, move-only, and caller-thread affine. It invokes no callbacks and exposes only copied outputs |
| ►CImpl | |
| CSnapshot | |
| CTile | |
| ►CTerrainMultiTreeWorkspace | Owning script-safe multi-terrain tree transaction workspace. Tree sets and height rasters are copied on insertion. Each operation and all-tile history snapshot is evaluated in a private candidate and published by one owner-thread swap. No external pointer, callback or hidden RNG survives |
| ►CImpl | |
| CSnapshot | |
| CTile | |
| CTerrainNoiseMaskSettings | Value-only 2D NoiseMask transform, fBm, optional domain-warp and deterministic-stream settings |
| CTerrainObjectInstanceSettings | One resource entry emitted around each accepted Pcg game-object prototype location |
| CTerrainObjectPlacementSettings | Deterministic Pcg SetTerrainGameObjects scan, collision and resource configuration |
| CTerrainObjectSpawnRule | One owned Pcg-style game-object spawn rule |
| CTerrainObjectTile | One exclusively borrowed terrain object owner and its immutable height source |
| CTerrainOperationTile | Immutable tile geometry and raster resolution used to calculate a shared operation window |
| CTerrainPipeline | Deterministic CPU terrain baking stages shared by editors and runtime tools |
| ►CTerrainPolygonMask | Own ordered Pcg-style PolyMask nodes and rasterize them into a caller-owned scalar grid. Nodes are value-copied and no terrain, texture, scene object, callback, clock, or RNG is retained |
| ►CImpl | |
| CNode | |
| CTerrainProbePlacementSettings | Deterministic value settings for Pcg SetProbes terrain scanning |
| CTerrainProbeSpawnRule | One owned Pcg-style reflection or light probe spawn rule |
| CTerrainProbeTile | One exclusively borrowed terrain probe owner and immutable height source |
| CTerrainRidgeSettings | Ridge controls in caller height units, with explicit clipping bounds. Defaults match the Pcg packed scalar domain [0,0.5]. World-height callers must supply their bounds. Passes counts actual shader applications: Pcg's UI iteration value N maps to floor(N)+2 passes, so its default 16 maps to 18 here |
| CTerrainRiverMeshBuilder | Builds overlapping flow-aligned water ribbons from a terrain river network |
| CTerrainRiverMeshSettings | TerrainRiverMeshSettings public API |
| CTerrainSample | TerrainSample public API |
| CTerrainSampleGrid | World X/Z positions of height sample centers, with positive spacing and dimensions |
| CTerrainSampler | Deterministic terrain height sampling (Red Blob Games / Perlin fBm recipe) |
| CTerrainSedimentSettings | Effective sediment coefficients from Hydraulic.compute, after UI conversion. The source hardcodes hardness to zero, disabling dissolution; capacity and dissolve controls therefore have no finite contribution and are not duplicated here |
| CTerrainSmoothSettings | Two-pass smoothing controls; radius in texels, verticality in [-1,1], strength in [0,1] |
| CTerrainSpawnPlan | Own an ordered mixed-domain Pcg-style spawn recipe. Rule IDs are stable and unique. Every raster and setting is copied at insertion, so later caller mutation cannot alter replay. The plan is a value object with no scene references, callbacks, clock or mutable external state |
| ►CTerrainSplatmap | Owning normalized terrain texture-layer weights with atomic mutation. Layers share one finite width/height topology and each texel sums to one within float tolerance |
| CImpl | |
| CTerrainSplatPalette | Ordered linear RGBA colors used to visualize terrain splat layers |
| CTerrainSplatSpawnRule | One owned Pcg-style terrain texture spawn rule |
| CTerrainSplatTile | Borrowed terrain splat owner and world geometry for one synchronous texture transaction |
| CTerrainStampSettings | Value configuration for a rectangular stamp in world X/Z coordinates |
| CTerrainStreamingCache | Runtime decoded-chunk cache for an EVTR terrain asset |
| CTerrainStreamingWindow | A rectangular, globally addressed terrain window assembled from resident chunks |
| CTerrainStreamStats | TerrainStreamStats public API |
| CTerrainTerraceRemovalSettings | Portable controls for Pcg HeightmapTerraceRemover's analysis and processing pipeline |
| CTerrainTerraceSettings | Terrace frequency in inverse height units, interior bevel in [0,1], strength in [0,1] |
| CTerrainTextureAlignSettings | World-space placement and Pcg-compatible seam blending controls for two splatmaps |
| CTerrainThermalSettings | Explicit simulation controls for the Pcg eight-neighbor thermal kernel. Height differences are multiplied by heightScale before slope comparison. Spacing is in simulation units; reposeSlope is tan(repose angle), not an angle in degrees. dt is the thermal substep duration (Pcg multiplies thermal dt by hydraulic dt). Defaults use unit spacing/height scale and tan(85 degrees), with three substeps |
| CTerrainTreePlacementSettings | Explicit deterministic tree placement configuration for one terrain rectangle and resource |
| CTerrainTreeRescaleSettings | Previous and replacement prototype values used for atomic Pcg-style tree refresh |
| CTerrainTreeSpawnRule | One owned Pcg-style tree spawn rule |
| CTerrainTreeTile | Borrowed terrain-local tree owner, height raster and world geometry for one synchronous transaction |
| ►CTerrainWaterField | Owned water/flux/velocity state for deterministic execution of the Pcg water stage. No terrain pointer is retained. Each advance reads an immutable terrain and previous field, computes all fluxes, then computes velocities and depth, publishing once. This deliberately retains the source's final rain/evaporation overwrite of transported depth and its velocity signs. It is not a conservative shallow-water solver. Undefined source behavior is resolved explicitly: current flux is fully computed before neighbor reads, and zero average depth produces zero velocity instead of division by zero. Thread affinity is caller-owned: exclusive reset/advance, immutable sampling when idle; no callbacks, borrowed output pointers, ECS handles, implicit clock or RNG |
| CImpl | |
| CTerrainWaterFlowMapSettings | Controls Pcg's legacy offline WaterFlowMap droplet tracer |
| CTerrainWaterSample | Value snapshot of one water cell; direction order follows Hydraulic.compute (Z+ is bottom) |
| CTerrainWaterSettings | Explicit constants for the source hydraulic water-flow equations, after UI unit conversion |
| CTerrainWorldClearSettings | Select Pcg spawn domains to clear in one atomic world operation |
| CTerrainWorldCreationSettings | Validated Pcg-style centered terrain-grid topology |
| ►CTerrainWorldWorkspace | Own a complete Pcg-style terrain grid and its height, splat, detail, tree, object and probe state. Creation and every operation publish by one owner swap. History snapshots contain every domain, so undo/redo cannot expose a height/resource combination that never existed. Inputs are copied during calls and never retained. The workspace is caller-thread affine, invokes no callback, reads no clock and uses only explicitly supplied seeds |
| ►CImpl | |
| CSnapshot | |
| CTile | |
| CTextureGenContext | TextureGenContext public API |
| CTextureRecipeDef | A procedural texture is fully described by an albedo ramp + a displacement field + PBR knobs. From one definition both an albedo recipe (ImageData) and a full PBR set (albedo/normal/roughness/metallic/height/ao) are produced |
| CTextureRecipeRegistry | EVENGINE_API_DOMAINS public API |
| CThermalErosionSettings | ThermalErosionSettings public API |
| CTilePresetVariant | Stable build semantics resolved from one eight-neighbour autotile mask |
| ►Nprocgen_animation | |
| CPcgSkinnedMeshPlan | Owned ordered inputs for Pcg's skinned MeshCombiner path |
| CPcgSkinnedMeshResult | Atomically published combined mesh and matching owned AnimSkin |
| CProcgenAnimation | Optional script composition for procedural meshes and skeletal animation |
| ►Nprocgen_editing | |
| CHeightmapTarget | Non-owning scalar-field adapter for a live procedural heightmap |
| CISplineBindingTransformSource | Consumer-owned transform lookup contract used by spline binding |
| CISplinePathDocumentEditTarget | UI-neutral reversible spline editing capability |
| CMeshModifierGraphCompileResult | Structural compilation result for a procgen.meshModifier graph document |
| CMeshModifierGraphDomain | UI-independent editor domain for the procgen mesh modifier graph |
| CMeshModifierGraphPreviewResult | Revision-tagged owning preview from a mesh modifier graph document |
| CMeshVertexAxisGizmoBuilder | Renderer-neutral runtime vertex-selection axis gizmo adapter |
| CPcgGraphCompileResult | Result of compiling a generic editor graph into a PointGraph asset definition |
| CPcgGraphMigrationResult | Transactional result of upgrading an editor PCG graph to the current schema |
| CPcgGraphPreviewMetric | One node's isolated PointGraph preview telemetry for graph overlays |
| CPcgGraphPreviewResult | Revision-tagged result of compiling and executing an isolated editor preview |
| CPcgInstancePublisher | Undoable publish/remove of spawn.mesh PointSet batches through Procgen scene sink |
| CPcgPointGraphDomain | procgen.point editor graph domain backed by procgen::PointGraph schema |
| CProcgenScriptDocumentTarget | Revisioned Params document for a script-hosted procedural generator |
| CProcgenScriptModuleSpec | Authored identity and reflected parameter schema for one script generator |
| CRoadNetworkEditTarget | Transaction target that edits stable RoadNetwork node/edge ids |
| CSceneQuerySplineBindingSource | Optional-scene adapter for the UI-neutral spline binding contract |
| CSplineBindingPose | Value snapshot resolved from a bound transform source |
| CSplineGizmoStyle | Renderer-neutral appearance settings for spline viewport overlays |
| CSplinePathBinder | Owning, pointer-free spline-to-transform binder with atomic document refresh |
| CSplinePathControlPoint | Stable authoring control point for a 3D spline path |
| CSplinePathDocument | Owning spline authoring document with transactional operations and schema-versioned snapshots |
| CSplinePathDragPreview | Immutable renderer-neutral spline drag preview |
| CSplinePathDragSession | UI-neutral ray picking and transient drag state for a spline document. @ownership Borrows the document; the caller must finish or cancel before destroying it. @thread Viewport/editor thread only; no callbacks are retained or invoked |
| CSplinePathGizmoBuilder | Builds sampled path, anchor and Bezier handle overlay primitives |
| CSplinePathSettings | Spline authoring settings stored independently from runtime caches |
| CSplinePointBinding | Persistent link from one spline control point to one scene transform identity |
| CTextureRecipePreviewArtifact | TextureRecipePreviewArtifact public API |
| CTextureRecipePreviewRuntime | Generates a candidate image and publishes it only after complete success |
| CTextureRecipeTarget | Revisioned, schema-driven procedural texture recipe asset |
| ►Nprocgen_editor | |
| CMeshModifierEditor | UI-neutral composition controller for modifier graph, spline, sculpt, UV-paint, merge, and adhere tools |
| ►CProcgenEditorModule | Composition adapter for the script-hosted procgen generator editor |
| CTargetFactory | |
| CProcgenScriptEditor | Workspace controller for one encapsulated procedural script module |
| ►Nprocgen_physics | |
| ►CGtsTerrainColliderRuntime | Transactional owner of optional static triangle-mesh colliders for a GTS tile batch |
| CImpl | |
| CProcgenPhysics | Script bridge for optional GTS terrain physics composition |
| ►Nproduction | |
| COutputRandomProvenance | Replayable provenance for domain-owned random output draws |
| CProduction | Script module factory for generic production queues |
| CProductionDependencies | Stable task-to-task constraints for a small production DAG |
| CProductionDiagnostic | Structured task diagnostic carrying stable correlation identity |
| CProductionEvent | Deterministically sequenced production lifecycle event |
| CProductionPrediction | Side-effect-free estimate under an unchanged queue configuration |
| CProductionRepeatPolicy | Repetition and externally reported maintain-stock contract |
| CProductionRequest | Validated input used to create a domain-neutral production task |
| CProductionReservationRelease | Idempotent release evidence used by a domain adapter to perform rollback/refund |
| CProductionResourceRequirement | Named capacity consumed while a task is running |
| CProductionSettlementReceipt | Owning proof that a domain consumer published one task exactly once |
| CProductionTask | A subject-agnostic continuous task retained for audit and save games |
| CProductionTerminationPolicy | Explicit cancellation and failure refund contract |
| CWorkContribution | Deterministic externally supplied work contribution |
| CWorkQueue | Generic multi-owner, multi-slot continuous-progress work queue |
| CWorkQueueHandleTag | Handle domain for a module-owned continuous-progress work queue |
| ►Nprof | |
| ►CProfiler | Global zone collector + per-frame aggregator |
| CFrame | |
| CThreadBuffer | |
| CZoneRecord | One completed profiling zone (pre-order, parent-linked within a thread) |
| CZoneSample | Per-module/per-zone aggregate of the last completed frame |
| CZoneScope | RAII scoped zone (used via the EV_PROFILE_* macros) |
| ►Nprofiler | |
| CProfiler | Script-facing wrapper around the engine-wide profiler core (eve::prof, see common/Profile.h) |
| CProfilerFrameSnapshot | Owning CPU/GPU profiler snapshot safe to retain across later frames |
| CProfilerZoneSnapshot | One owning profiler row copied from the last completed frame |
| ►Nprofiler_editing | |
| CEditorProfilerBudgets | Configurable performance budgets used only for editor diagnostics |
| CEditorProfilerCollector | Optional profiler-module bridge that copies one completed runtime frame. @thread Main-thread only, after the runtime profiler completed frame aggregation. @reentrancy Does not invoke callbacks or scripts |
| CEditorProfilerFrame | One owning completed-frame sample retained by the editor |
| CEditorProfilerModel | Bounded owning profiler history and deterministic presentation queries. @thread Main-thread only. @reentrancy Does not invoke callbacks. @ownership Owns all retained frame and string data; it does not own the runtime profiler |
| CEditorProfilerModuleSummary | Aggregated module timing for the latest completed frame |
| CEditorProfilerQuery | Non-persistent query applied to the latest profiler frame |
| CEditorProfilerZone | One owning profiler hotspot row projected for editor presentation |
| ►Nproperty_access | |
| CIPropertyAccess | Renderer- and transaction-independent MVVM property surface |
| CNumericMetadata | Numeric editing metadata independent of a slider or spin-box widget |
| CPropertyChange | Immutable notification emitted after a model property changes |
| CPropertyDescriptor | One stable property description consumed by any UI shell |
| CPropertySchema | Versioned schema for one view model or editable target |
| ►CReflectedPropertyModel | Adapts one live Squirrel instance to the renderer-independent property model |
| ►CObserverState | |
| CEntry | |
| CWriteResult | Result of a model write, including a stable diagnostic code |
| ►Nqueue_editing | |
| CQueueEventSnapshot | Runtime-neutral lifecycle event for timeline presenters |
| CQueueInspectionSnapshot | Immutable queue inspection result with structured diagnostics |
| CQueueItemSnapshot | Runtime-neutral retained queue item for inspector tables |
| CRuntimeQueueInspector | Safely copies short-lived Orders and Production observations for editor use |
| ►Nresource | |
| CAccountNonce | Opaque process-local identity of the account that issued a credential |
| CAffordability | Structured answer to a canAfford query |
| CAmount | Non-negative integral quantity used by resource accounts |
| CCostInput | Convenient unvalidated input used by CostSpec::from() |
| CCostSpec | Immutable canonical multi-resource cost |
| CIResourceAccount | Provider-neutral resource account contract |
| CReceipt | Receipt proving one atomic debit or credit was applied |
| CReservation | Reservation credential returned by a successful reserve operation |
| CResourceCost | One positive resource and quantity pair in a canonical cost |
| CResourceId | Strong identity of a resource kind, such as mana or gold |
| CResourceShortfall | A resource missing from an affordability query |
| ►Nrpg | RPG 模块的基础实体：把属性 / 状态 / 技能三张表挂到一个 ECS 实体上。 |
| CAttributeSystem | RPG-facing attribute operations backed by the canonical AttributeSet |
| CBattle | 一场回合制战斗（任意阵营数）。 @ownership 由调用方创建/销毁；Battle 不持有参与者的所有权（参与者为借用 ECS actor）。 @thread 在单一模拟线程上驱动整场战斗。 |
| CBattleControl | Explicit stable-identity adapter over one caller-owned RPG battle |
| CBattleEvent | 一次战斗反馈事件。 |
| CBattleSystem | 战斗数值：公式求值 + 技能伤害注册 + 结算。 @thread 纯计算，可在任意线程执行。 |
| CBattleTacticRule | One ordered tactic rule; an empty condition resource is an unconditional default |
| CBattleTacticsCatalogue | Process-local strict catalogue that selects and queues companion/AI actions |
| CBattleTacticsDefinition | One immutable ordered tactic definition |
| CBattleVictory | Product transaction boundary for post-battle rewards and encounter lifecycle |
| CBattleVictoryReceipt | Observable summary returned after a complete victory settlement |
| CBattleVictoryRequest | Complete data needed to settle one victorious persistent encounter |
| CCastingState | 施法状态：同一时间每个 actor 只有一个进行中的引导/读条（可按需扩展为多槽）。 |
| CClassDefinition | 数据驱动的职业模板。 |
| CClassLearnSkill | 一条"升到 level 级可学 skillId"的规格。 |
| CClassRegistry | 进程级职业定义注册表。 |
| CClassSystem | 职业系统。 @thread 调用线程应与 RPGActor 的 ECS 线程一致。 |
| CCrafting | Composes RPG recipes with existing production and inventory owners |
| CCraftingReceipt | Receipt for an accepted recipe job |
| CCraftingRecipe | Validated recipe projection used by crafting, alchemy, brewing and cooking |
| CCraftingRequest | Borrowed inputs for atomically paying ingredients and enqueuing recipe work |
| CDamageResult | 一次命中结算结果。 |
| CEffectDefinition | EVENGINE_API_PLATFORM public API |
| CEffectModifierSpec | 效果里携带的一条属性修改规格（应用到 AttributeSystem::addModifier）。 |
| CEffectRegistry | 全局效果定义表：进程级单例，供任意模块 / 脚本按 id 引用。 |
| CEncounterCatalogue | Process-local strict encounter content catalogue |
| CEncounterDefinition | One immutable, fully specified encounter composition and settlement definition |
| CEncounterMemberDefinition | One immutable enemy member inside an encounter composition |
| CEquipmentStat | 一件物品的一条属性加成规格。 |
| CEquipmentSystem | 装备加成系统。 @thread 调用线程应与 RPGActor 的 ECS 线程一致。 |
| CGameState | 一份游戏状态（开关/变量/独立变量）。 |
| CLevelSystem | 成长系统：读写 RPGActor::Progression 并驱动升级事件。 @thread 调用线程应与 RPGActor 的 ECS 线程一致。 |
| CLevelUpEvent | 升级事件。 |
| CLootEntry | 掉落表里的一条掉落。 |
| CLootSystem | 掉落系统：进程级掉落表 + 随机 roll 入包。 @thread roll 使用调用方提供的 rng（命名随机流），可在任意线程执行。 |
| CLootTableDefinition | 掉落表定义。 |
| CObjectiveRuntime | 单条目标的运行时进度。 |
| CParty | Authoritative ordered relationship between stable party member IDs and RPG actors. @ownership Party owns only stable IDs and generation-qualified links; the RPG ECS world owns actors. @thread Use on the actors' owning simulation thread |
| CPreparedProgressionGain | Move-only progression gain prepared against one actor revision |
| CProductControl | Host-neutral adapter joining shop, quest-reward and world-loot transactions |
| CQuestDefinition | 数据驱动的任务模板。 |
| CQuestEvent | 追踪器事件：activate | progress | ready | complete | fail | reset | reject。 无关字段为空 / 0。 |
| CQuestObjective | 一条目标：听哪个 notify、要多少次。target 空 = 只匹配 topic。 |
| CQuestRegistry | 进程级任务定义注册表。 |
| CQuestReward | Product-level transaction boundary for quest completion and rewards |
| CQuestRuntime | 一条任务在本 Tracker 上的运行时状态。 |
| CQuestSystem | EVENGINE_API_PLATFORM public API |
| CRewardSpec | 奖励规格（定义侧数据）。引擎不发奖，仅提供查询。 |
| CRPG | RPG 模块（eve.RPG）：Actor 工厂 + 定义注册 + 帧调度 + 事件缓存。 |
| ►CRPGActor | 属性 / 状态 / 技能三表合一的 ECS 实体。 |
| CAttributes | 属性组件：AttributeSet 是属性状态与计算的唯一权威真源。 |
| CClassInfo | 职业：当前职业 id + 已同步学技能的等级上限。 |
| CProgression | 成长进度：等级 / 经验 / 升级所需经验。 |
| CSkills | 已学会技能的冷却状态 + 当前读条状态。 |
| CStatuses | Status lifecycle component backed by the generic effects container |
| CTraitInstance | 已施加的运行时特征实例。 |
| CTraits | 该 actor 的活动特征列表（TraitSystem 读写）。 |
| CVitals | 当前资源（hp / mana ...）：current 是运行时瞬时值，上限取同名最终属性。 max 由 attributes 推导（getFinalAttribute(resource)），本组件只存 current。 |
| CRPGSaveSession | A non-owning save boundary for the persistent classic-RPG state owners |
| ►CRPGSettlementAdapter | Settles damage/healing against one RPG actor's AttributeSet |
| CConfig | Attribute names used by the RPG policy |
| CRpgStoryBinding | Borrowed domain objects an RPG story step runs against |
| CRpgStoryCatalogue | Strict process-local catalogue of .dnut story assets |
| ►CRpgStorySession | Caller-owned cursor over one published .dnut story |
| CImpl | |
| CSettlementContext | 结算上下文：通用的读写数据袋，字段完全由调用方与各阶段自行约定。 |
| CSettlementPipeline | Compatibility-only named calculator retained for existing RPG scripts |
| CShopCatalogue | Process-local validated offer catalogue used by RPG shop transactions and UI |
| CShopOffer | One immutable offer in the process-local shop catalogue |
| CShopTransaction | Product transaction boundary for an RPG shop trade |
| CSkillActionAdapter | Translates a SkillDefinition into the common gameplay action model |
| CSkillCastEvent | 技能释放结算事件：由 SkillSystem 在读条完成 / 瞬发技能释放时产生。 |
| CSkillConditionAdapter | Evaluates a condition using RPG Skill state without mutating it |
| CSkillConditionContext | EvaluationContext backed by one borrowed RPG actor and SkillDefinition |
| CSkillConditionQueries | Read-only extension points for authority and policy queries |
| CSkillDamageSpec | 一次技能命中的伤害规格。 |
| CSkillDefinition | SkillDefinition public API |
| CSkillDefinitionRuntime | Typed SkillDefinition-to-runtime adapter |
| CSkillRegistry | EVENGINE_API_PLATFORM public API |
| CSkillRuntime | 单个已学会技能的运行时状态（冷却）。 |
| CSkillRuntimeState | Mutable state belonging to one learned skill instance |
| CSkillSystem | EVENGINE_API_PLATFORM public API |
| CStatusChangeEvent | 状态生命周期变更事件（施加 / 刷新 / 叠层 / 延长 / 移除 / 到期 / 拒绝）。 与 StatusTickEvent 分开：tick 是周期性数值触发，change 是实例结构变化。 |
| CStatusExecutorMetadata | RPG executor state associated with one canonical effect instance id |
| CStatusInstance | Legacy RPG projection of one effects::EffectInstance |
| CStatusSystem | EVENGINE_API_PLATFORM public API |
| CStatusTickEvent | 周期性状态触发的 tick 事件。周期效果（period > 0）不会自动修改属性， 而是每个周期产生一个 tick 事件交给上层（脚本或 C++ 结算系统）处理—— 这样伤害/治疗类周期效果可以完整地走 Settlement 流水线（护甲、抗性、暴击……）， 而不是被引擎硬编码为直接扣血。 |
| CStatusUpdateSummary | Summary returned by the checked RPG status executor update |
| CStoryAnimationRequest | One animation step request, expressed in the host's own animation space |
| CStoryEventCatalogue | Strict process-local catalogue for versioned story-event content |
| CStoryEventDefinition | One immutable, ordered and resumable story-event definition |
| CStoryEventSession | Caller-owned runtime cursor over a copied story-event definition |
| CStoryEventStep | One immutable presentation command owned by a story-event definition |
| CStoryMoveRequest | One move step request, expressed in the host's own movement space |
| CTracker | 一份任务进度 + 本实例事件队列。 |
| CTraitDefinition | 数据驱动的特征模板。 |
| CTraitRegistry | 进程级特征定义注册表。 |
| CTraitSpec | 特征承载的一条能力规格。 |
| CTraitSystem | 特征系统。 @thread 调用线程应与 RPGActor 的 ECS 线程一致。 |
| CVitalsEvent | 生命等资源事件：damage | heal | death | revive。 |
| CVitalsSystem | 当前资源系统：读写 RPGActor::Vitals 并发出事件。 @thread 调用线程应与 RPGActor 的 ECS 线程一致。 |
| CWorldInteraction | Product transaction boundary for persistent world-object rewards |
| CWorldLootRequest | Complete data needed to settle one persistent loot object |
| CWorldState | Non-owning typed adapter for persistent per-map object lifecycle state |
| ►Nrts | |
| CAbilitySpec | Typed ability policy; lifecycle effects remain owned by the canonical effect container |
| CAbilitySystem | Validates, schedules and settles active RTS abilities through canonical damage/effect owners |
| ►CActionAdapter | Adapter that maps RTS orders to the existing action::ActionRuntime |
| ►CImpl | |
| CPending | |
| CActionExecutionResult | Owning, domain-local projection of an action adapter outcome |
| CActionLinkTag | ActionLinkTag public API |
| CAISystem | Runs deterministic faction production and attack policy |
| CArtilleryRelocationSelection | Deterministic, canonical-map-validated artillery relocation choice |
| CArtilleryRelocationSystem | Selects reachable shoot-and-scoot positions without taking ownership of map navigation |
| CArtillerySystem | Tracks indirect-fire deployment after movement |
| ►CAttributeComponent | Canonical attributes component adapter, backed by attributes::AttributeSet |
| CImpl | |
| CAuthorityLinkTag | AuthorityLinkTag public API |
| CBuildInfluenceSystem | Composes RTS powered build influence with the canonical building placement authority |
| ►CBuilding | RTS building domain root with placement and production composition |
| CCapture | Deterministic contested capture state |
| CCombat | Automatic targeting policy for a stationary defensive building |
| CCommand | Static command provider and hostile jamming policy |
| CConstruction | Construction progress and generation-checked assigned builders |
| CDefinition | Logical building definition identity |
| CDropoff | Resource delivery policy; actual balances remain in the economy provider |
| CEconomy | Economy account/provider link |
| CEffects | Lifecycle-only effects |
| CFaction | Owning faction link |
| CGarrison | Building garrison capacity and generation-checked occupants |
| CIdentity | Runtime identity |
| CIndirectFire | Last indirect-fire exposure for static artillery and counter-battery observation |
| CInfrastructure | RTS infrastructure projection; economy balances remain owned by the linked provider |
| CIntegrity | Building health and repair economy configuration |
| COrders | Generic building orders |
| CPlacement | Placement world key and authoritative cell state |
| CProduction | Canonical production queue |
| CRally | Rally order copied to newly produced units |
| CSettlement | Settlement provider link |
| CShield | RTS shield layer for structures; canonical CombatState remains health authority |
| CSupply | Static ammunition stock and transfer policy for completed buildings |
| CTags | Building-local tags |
| CTechnology | Upgrade ids already projected onto this building |
| CVision | Static vision contribution projected into a faction-owned canonical map FOV provider |
| CWeapon | Canonical weapon entity used by an armed building |
| CBuildingLinkTag | BuildingLinkTag public API |
| CBuildingProductionSystem | EVENGINE_API_DOMAINS public API |
| CCaptureSystem | Resolves deterministic single-faction and contested building capture |
| CCombatFireEvent | Stable presentation payload for firing, launch, and miss feedback |
| ►CCombatFireSystem | EVENGINE_API_DOMAINS public API |
| CState | Adapter-owned keys previously mirrored into a shared sensing world |
| CCombatHeightProfile | Absolute muzzle and target heights resolved by the authoritative map/game adapter |
| CCommandFanOutSystem | Validates a typed selection and fans one command out in formation order |
| CCommandNetworkSystem | Builds deterministic faction command networks with relay capacity and hostile jamming |
| CCommandSpec | One domain-neutral command submitted to a unit's generic order queue |
| CCommandStateSystem | Applies immediate Stop and persistent Hold/AttackMove command state |
| CConstructionSystem | Advances construction using valid builders that reached their assigned site |
| CContainerLinkTag | ContainerLinkTag public API |
| CContainmentSystem | Resolves transport boarding, building garrisoning, and contained-unit synchronization |
| CContentImportReceipt | Receipt for one atomically imported RTS content pack |
| CCrowdLinkTag | CrowdLinkTag public API |
| CCrowdMotionSystem | Synchronizes linked RTS units through the canonical Crowd simulation |
| CEconomyLinkTag | EconomyLinkTag public API |
| CEffectSystem | Advances lifecycle-only effects on Units and Buildings |
| CEntityLink | Generation-checked link to an ECS entity |
| CEntityLinkTag | Typed link tag for links to another ECS entity |
| ►CFaction | Faction domain root; membership is a set of typed runtime handles |
| CAuthority | Authority provider link |
| CEconomy | Economy account/provider link |
| CGameEvent | Event stream/provider link |
| CIdentity | Runtime identity |
| ►CIntel | Persistent last-known enemy contacts derived from the faction's canonical FOV provider |
| CContact | Contact public API |
| CMembers | Authoritative faction membership handles |
| ►CProductionPolicy | Cross-factory resource floors reserved for production at or above a priority threshold |
| CReserve | Reserve public API |
| CSocial | Social graph/provider link |
| CStrategy | Deterministic high-level production and attack policy for an AI-controlled faction |
| CTechnology | Completed research definitions and canonical production tasks already consumed |
| CWorkforce | Deterministic idle-worker assignment policy for construction and repair |
| CFactionIntelSystem | Reads authoritative faction contact projections for command authorization |
| CFactionLinkTag | FactionLinkTag public API |
| CFactionRelationSystem | Resolves same-faction and match-team alliances without duplicating diplomacy state |
| CFanOutReceipt | Receipt containing all order ids accepted by command fan-out |
| CFireSupportSystem | Assigns indirect-fire responders and automatic counter-battery ground attacks |
| ►CFogOfWarSystem | Projects RTS vision into canonical map FOV and maintains faction last-known contacts |
| ►CState | Runtime-only revealer bindings; authoritative explored cells remain owned by map::Fov |
| CBinding | Binding public API |
| CFormationPlanner | Pure deterministic formation planner |
| CFormationSpec | Input to the pure formation planner |
| CGameEventLinkTag | GameEventLinkTag public API |
| CInfrastructureSystem | Allocates faction power deterministically and settles powered passive income |
| CIRTSActionExecutor | Interface isolating RTS orders from the shared action runtime |
| CLifecycleEvent | Stable payload for one committed RTS lifecycle transition |
| ►CMatch | Independent match composition root; factions may participate in different matches |
| ►CEvents | Deterministic retained lifecycle events |
| CEvent | Event public API |
| CIdentity | Runtime and persistent identity |
| ►CParticipants | One faction's team and elimination projection |
| CEntry | Entry public API |
| CRules | Configured victory rule; immutable while the match is running |
| CState | Authoritative match outcome |
| CMatchSystem | Match command and simulation boundary |
| CMiningSystem | Advances Gather/ReturnCargo orders without owning an economy balance |
| CMoraleSystem | Recovers suppression and applies nearby friendly morale auras |
| CMotionSystem | Moves units toward their active generic order targets |
| CMovementGroupBatch | Caller-built admission batch for an immediate coordinated Move command. @cost Linear in unit count; callers own and pass stable identities once per command admission |
| CMovementOrderSystem | Settles arrived finite movement orders so the canonical queue can advance |
| CNavigationGrid | World/grid conversion used when an RTS composition consumes a canonical map Pathfinder |
| CNavigationSystem | Plans unit routes through the canonical map Pathfinder without owning map blockers or costs |
| COrderActionSystem | Sends active generic orders to one shared action executor |
| ►COrderComponent | Generic orders component adapter; the queue remains the sole order owner |
| CImpl | |
| CSnapshot | Complete RTS order projection snapshot; entity handles must be rebound by the owning domain |
| COrderRecord | Owning projection of the active generic order used by RTS systems |
| CPatrolSystem | Maintains persistent two-point patrol state without owning pathfinding |
| CPlacementLinkTag | PlacementLinkTag public API |
| ►CPlayer | Player domain root; selection is RTS-local, authority/economy/social are links |
| CAuthority | Authority provider link |
| CEconomy | Economy account/provider link |
| CGameEvent | Event stream/provider link |
| CIdentity | Runtime identity |
| CSelection | RTS-owned selection handles; handles are generation checked on use |
| CSocial | Social graph/provider link |
| ►CProductionComponent | Production adapter whose queue owns all task state |
| CImpl | |
| CProductionSpawnOutcome | Factory outcome; blocked tasks retain their payment and reserved identity |
| CProjectileCollision | Earliest canonical collision found along one projectile sweep segment |
| CReinforcementProductionPolicySystem | EVENGINE_API_DOMAINS public API |
| CReinforcementRequestReceipt | Result of resolving a preferred reinforcement through a deterministic substitution chain |
| CReinforcementSystem | Dispatches and unloads production reinforcements assigned to canonical unit containers |
| CRepairSystem | Repairs friendly completed buildings without owning an economy balance |
| ►CResourceNode | Harvestable RTS resource node; deposited balances are owned by an external resource account |
| CHarvest | Concurrent worker capacity and current generation-checked assignments |
| CIdentity | Runtime and persistent identity |
| CPosition | Authoritative world position and interaction radius |
| CStock | Authoritative remaining resource stock |
| CResourceNodeLinkTag | ResourceNodeLinkTag public API |
| ►CRTS | Owns RTS root entities and coordinates the phase-one systems |
| CGameplayRuntime | |
| ►CScriptRuntime | |
| CCheckpoint | |
| CEconomySlot | |
| CPaidConstruction | |
| CPaidProduction | |
| CRTSArchetypeMaterializer | Materializes canonical unit/building definitions into RTS composition components |
| CRTSBuildingSnapshot | One module-owned building snapshot with stable RTS relationships |
| CRTSBuildReceipt | Result of an accepted atomic RTS build/production command |
| CRTSBuildRequest | Caller-owned inputs for one atomic RTS build or production command |
| CRTSCancelProductionReceipt | Result of a production cancellation whose queues and refund all committed |
| CRTSCancelProductionRequest | Caller-owned inputs for atomically cancelling one paid production task |
| CRTSCommandLog | Deterministic lockstep input buffer and portable command log |
| CRTSContentLoader | Validates legacy-compatible RTS content packs and publishes their records to Definitions |
| CRTSEconomyAdapter | Connects an RTS player's economy to one atomic gameplay payment |
| CRTSEffectAdapter | RTS adapter that keeps the common container as the sole instance owner |
| CRTSEffectComponent | Entity-local RTS effect component backed by the canonical adapter |
| CRTSEffectDefinition | Typed RTS definition projected to the common lifecycle schema |
| CRTSEffectExecutor | RTS executor for morale, suppression and production-lock semantics |
| CRTSEffectSnapshot | Serializable in-memory RTS effect snapshot |
| CRTSEffectTarget | Mutable RTS state affected by the domain executor |
| CRTSEffectUpdate | Result of one RTS lifecycle step and domain settlement |
| CRTSFactionSnapshot | Faction-owned strategy, workforce, intelligence, technology, and stable membership |
| CRTSFrameCombatEvent | Owning transient projection of one committed canonical weapon lifecycle event |
| CRTSFrameDamageEvent | Owning transient projection of one canonical damage transaction completed this RTS frame |
| CRTSFrameLifecycleEvent | Owning transient projection of one committed non-combat RTS lifecycle event |
| CRTSLockstep | Fixed-step coordinator that applies lockstep inputs before the existing RTS system pipeline |
| CRTSMatchParticipantSnapshot | Match participant projection without process-local faction links |
| CRTSMatchSnapshot | Independent RTS match state and retained deterministic events |
| ►CRTSMovementGroupSnapshot | Stable pacing-group membership; entity handles and derived speed factors are excluded. @cost Linear in group member count; copied only in RTS snapshot capture/restore |
| CMember | Stable member identity and the exact command whose lifetime binds membership |
| CRTSPlayerSnapshot | Player-local RTS selection; authority/economy/social providers remain external |
| CRTSProductionActionAdapter | Coordinates Orders, Production, Action and resource payment |
| CRTSProductionResourceReserve | Resource amount protected from production requests below a configured priority |
| CRTSProjectilePayloadSnapshot | Stable RTS damage payload paired with one shared projectile-pool handle |
| CRTSProjectileSystem | RTS impact adapter over the canonical pooled weapon projectile trajectory runtime |
| CRTSProjectileSystemSnapshot | Complete in-flight RTS projectile state with stable gameplay relationships |
| CRTSReplayCommand | One process-independent command using stable subjects instead of ECS handles |
| CRTSResourceNodeSnapshot | One module-owned resource-node snapshot with stable worker assignments |
| CRTSStateSnapshot | Complete RTS-owned state; v2 adds movement groups, v1 imports with no groups. @cost Linear in saved entity and relationship counts; capture/restore copies owned snapshot vectors at checkpoint boundaries |
| CRTSUnitAttributeAdapter | Defines the small set of RTS unit stats eligible for attributes |
| CRTSUnitSnapshot | One module-owned unit snapshot; external provider links are intentionally excluded |
| CRTSWorkerSnapshot | Persisted worker projection with stable references to its assignments |
| CSensingLinkTag | SensingLinkTag public API |
| CServiceLink | Strong key link to an external module-owned service object |
| CServiceLinkTag | Typed link tag for a provider-owned capability or registry entry |
| CSettlementLinkTag | SettlementLinkTag public API |
| CShieldSystem | Regenerates unit and building shield projections after their configured damage delay |
| CSocialLinkTag | SocialLinkTag public API |
| CSteeringLinkTag | SteeringLinkTag public API |
| CSupplyConvoySystem | Derives stable multi-vehicle supply convoys and paces their leader |
| CSupplyRendezvousSelection | A safe map-reachable rendezvous selected around a predicted moving relay intercept |
| CSupplyRendezvousSystem | Selects a low-threat supply rendezvous while delegating reachability to the canonical map |
| CSupplySystem | EVENGINE_API_DOMAINS public API |
| CSystemContract | Static metadata for one ECS system's access and phase contract |
| CTacticsSystem | Updates escort guards and deterministic combat-group target commitments |
| CTagSet | Entity-local sorted tags; this is the RTS entity's tag authority |
| CTechnologySystem | Settles completed research tasks and projects unlocked upgrades idempotently |
| CTrafficReservationSystem | Arbitrates deterministic directional entry into connected narrow map corridors |
| ►CUnit | RTS unit domain root |
| ►CAbilities | Ability cooldowns and an optional deterministic cast/channel in progress |
| CChannel | Channel public API |
| CCooldown | Cooldown public API |
| CAction | Shared action runtime/provider link |
| CArtillery | Indirect-fire deployment and deterministic area-fire policy |
| CAttributes | Canonical attribute state |
| CCapture | Capture contribution while executing a Capture order |
| CCombat | RTS stance and pursuit limits used by automatic combat policies |
| CCommand | Command-network policy and derived connection state for a mobile unit or relay |
| CContainment | Unit containment state for transports and building garrisons |
| CCrowd | Crowd provider link |
| CDefinition | Logical unit definition identity |
| CDurability | Canonical combat durability state consumed by combat::DamageRuntime |
| CEffects | Lifecycle-only active effects |
| CFaction | Owning faction link |
| CIdentity | Runtime identity and logical unit definition |
| CMorale | Suppression, recovery, retreat policy, and friendly morale aura |
| CMotion | Authoritative kinematic state used by the phase-one move slice |
| CNavigation | RTS projection of a canonical map path; the map provider remains the grid authority |
| COrders | Generic command/order state |
| CSensing | Sensing provider link |
| CSettlement | Settlement provider link |
| CShield | RTS shield layer consumed before canonical health damage and regenerated deterministically |
| CSteering | Steering provider link |
| CSupply | Tactical ammunition logistics; weapon ammunition remains authoritative in WeaponEntity |
| CTactics | Escort geometry and combat-group coordination state |
| CTags | Entity-local tags |
| CTechnology | Upgrade ids already projected onto this unit, preventing repeated multiplicative application |
| CVeterancy | Persistent combat experience and deterministic veteran/elite modifiers |
| CVision | Vision contribution projected into a faction-owned canonical map FOV provider |
| CWeapon | Weapon entity link |
| CWorker | Worker gathering and delivery state; balances remain owned by the linked economy account |
| CVeterancySystem | Applies one hostile kill's experience to canonical unit veterancy state |
| CWeaponLinkTag | WeaponLinkTag public API |
| CWorkerAssignmentSystem | Deterministically assigns idle auto-workers to compatible resource nodes |
| CWorkforceAssignmentSystem | Assigns idle faction workers to incomplete or damaged buildings by deterministic distance |
| CWorldPosition | Two-dimensional deterministic RTS world position |
| ►Nrx | |
| CAnonymousObservable | Internal: observable built directly from a subscribe function |
| CBehaviorSubject | Subject that replays the latest value to every new subscriber. setValue()/onNext() update the stored value and push it to observers |
| CObservable | Push-based stream source. Operators return a new (caller-owned) Observable; subscribe() returns a Subscription used to cancel |
| CObserver | Callback bundle pushed to a subscriber. Once error() or completed() fires the observer is stopped and later notifications are ignored |
| CReactiveProperty | Observable value backed by a BehaviorSubject. get() returns the current value; set() stores and pushes it to subscribers |
| CReplaySubject | Subject that buffers up to capacity values (0 = unlimited) and replays the buffer to every new subscriber |
| CRx | |
| CSubject | Multicast push-based stream: both an Observable and a push source. Thread-safe: onNext/onError/onCompleted/subscribe are mutex-protected |
| CSubscription | RAII-style dispose handle for an active stream subscription. Disposing unsubscribes from the source; move-only |
| CValue | Runtime variant used by the script-facing (Squirrel) streams. The C++ core is templated (Observer<T>/Observable<T>/Subject<T>); the module binds a Value-typed specialization so scripts can push nil/int/float/bool/ string/ptr |
| ►Nscene | |
| CAABB3f | Axis-aligned box in world space |
| CCameraClip | Camera view-projection matrix and its inverse for one viewport |
| CFollowPlayerInput | Per-frame player observation supplied by the application |
| CFollowPlayerOutput | Provider-neutral transform writes produced for every followed object |
| CFollowPlayerSettings | Pcg FollowPlayerSystem configuration independent of render providers |
| CISceneCameraProjection | Camera projection queries answered by the module that owns Camera3D |
| CLinkOps | LinkOps public API |
| CLocationBookmark | One named Pcg location bookmark with optional player transform metadata |
| CLocationPose | Provider-neutral position and quaternion stored by Pcg's location profile |
| CLocationProfile | Caller-owned Pcg location and bookmark state. Mutable operations validate complete candidate data before publication. No scene objects are retained |
| CLocationSnapshot | Loaded camera/player transform pair |
| CNodeDesc | Declarative scene-node description (build once / on dirty → flatten into SceneHost::Tree). Isomorphic to eve::ui::WidgetDesc |
| CPcgBuildConfig | Caller-owned Pcg publication configuration and ordered build history |
| CPcgBuildLogEntry | PcgBuildLogEntry public API |
| CPcgGrowth | Caller-owned one-shot Pcg Growth state with explicit time and random seed |
| CScene | Declarative scene module (eve.Scene) |
| CSceneArtifactHandleTag | Owner tag for scene artifact runtime handles |
| CSceneArtifactNode | Backend-neutral node observable emitted for one artifact part |
| CSceneArtifactProvider | Real scene-module provider for generated artifact publication |
| CSceneArtifactRecord | Queryable scene registry record for one published artifact |
| CSceneArtifactStage | |
| CSceneComponent | React-style scene component: implement build(), call setState / markDirty, then rebuild(). Mounts onto a named SceneHost via mountAs / attach. Isomorphic to eve::ui::Component |
| ►CSceneHost | ECS mount point for one scene graph (full scene or nested subtree root). Isomorphic to eve::ui::UIHost |
| CMeta | Meta public API |
| CTree | |
| CSceneLink | SceneLink public API |
| CSceneNode | Retained scene node (arena). Conceptual GameObject; isomorphic to eve::ui::UINode |
| CSceneNodeRef | Script handle to a scene node (hostName + nodeId). Deliberately holds strings rather than arena pointers, so it stays valid across rebuilds/reconcile. Node-level entity bindings are forwarded through the Scene module |
| ►CSceneObject | Per-node ECS identity (created lazily when a node needs script bindings or engine components). A node's stable string id (hostName + nodeId) is mirrored here so ECS systems can address scene nodes and vice versa |
| CMeta | Meta public API |
| CScriptBindings | |
| CScreenRay | World-space ray through one screen pixel |
| CTransformSystem | Propagates local TRS → world matrices for all SceneHost trees (or one host). Call after mount/reconcile or local transform edits |
| ►Nscene_editing | |
| CCreateSceneObjectRequest | Request used to create a scene object in either backend |
| CISceneComponentInspector | Read-only live component/link inspection capability for scene inspectors |
| CISceneComponentPayloadProvider | Module-owned adapter for one scene component payload type |
| CISceneComponentPayloadTarget | Scene capability that discovers and routes module-owned component payload editors |
| CISceneHierarchyEditTarget | Stable hierarchy capability implemented by document and runtime targets |
| CITransformEditTarget | Capability implemented by document and live scene targets |
| CRuntimeWorldTarget | Live game-world backend exposing the same standard scene capabilities |
| CSceneComponentLinkSnapshot | Safe metadata for one external component link on a live scene object |
| CSceneComponentPayloadRef | Stable, pointer-free reference to one editable component instance |
| CSceneComponentPayloadRegistry | Non-owning registry and scene-facing router for component payload providers |
| CSceneComponentPropertyBindings | Reuses existing property/operation targets as scene component payloads |
| CSceneDocumentTarget | Authoring scene-document backend exposing the standard scene capabilities |
| CSceneHierarchyToolLogic | Backend-neutral hierarchy editing logic for outliner-style tools |
| CSceneHostEditorTarget | Optional live adapter mirroring editor operations into one SceneHost |
| CSceneObjectSnapshot | Immutable scene object snapshot returned across target boundaries |
| CScenePlacementToolLogic | Backend-neutral placement logic suitable for a Tool, script or command handler |
| CScenePropertyProvider | Property adapter exposing scene TRS to generic inspector presenters |
| CSceneTargetBase | Shared in-memory scene target implementation for document/runtime adapters |
| CSceneTransformToolLogic | Backend-neutral transform logic suitable for a Tool, script or command handler |
| CSceneTransformValue | Serializable transform exchanged across the scene editing boundary |
| ►Nscene_editor | |
| CPhysicsPlacementAdmissionPolicy | Host-supplied filters used before objects enter the private preview world |
| CPhysicsPlacementCollider | One local-space shape in a possibly compound placement collider |
| CPhysicsPlacementFrame | Captured placement state suitable for drawing and final transaction planning |
| CPhysicsPlacementObject | Scene object and collision approximation admitted into an isolated placement preview |
| CPhysicsPlacementRequest | Owning request used to construct one isolated placement candidate |
| CPhysicsPlacementSettings | Deterministic policy for collision-aware scene placement |
| ►CSceneEditorModule | Composition adapter that contributes scene editing commands and automation targets |
| CTargetFactory | |
| ►CSceneEditorSession | Composable scene command/history host with no UI or renderer dependency. Owns its target, command registry and history. Host supplies selection, input, rendering and file I/O; snapshot JSON contains hierarchy/TRS only. @thread Owner thread only. Live targets may notify host observers after publication, without locks. Observers must not destroy or reenter the active session |
| ►CImpl | |
| CCachedHull | |
| ►CScenePhysicsPlacementBackend | Real Box3D-backed, non-destructive simulation backend for scene placement |
| ►CImpl | |
| CRuntimeObject | |
| ►Nscene_physics | |
| CScenePhysics | Scene/runtime composition entry point for generated colliders in a shared World3D |
| ►Nsceneloader | |
| CLoadOptions | Options controlling how a 3D scene file is decoded and mounted |
| CMeshSlot | A GPU mesh reference for one Assimp mesh referenced by an aiNode. The loader uploads one Renderable3D (with its own mesh + material) per aiMesh, so every mesh is an independently diffable GameObject and unchanged meshes are never re-uploaded across a hot reload. With LoadOptions::sharedMeshes the same aiMesh referenced by several nodes uploads a single GPU buffer |
| CSceneDiff | SceneDiff public API |
| CSceneDiffEntry | SceneDiffEntry / SceneDiff |
| CSceneInspection | CPU-only import inspection result used by editor preflight |
| ►CSceneLoader | Loads a 3D scene (glTF / OBJ / FBX / GLB ... via Assimp/medialoader) into the ECS scene tree |
| CCpuImage | CPU-decoded texture (RGBA8) keyed by the same source+suffix key as TextureCache |
| ►Nsceneloader_editing | |
| CSceneImportPreflight | SceneImportPreflight public API |
| CSceneImportPreflightRuntime | EVENGINE_API_ORCHESTRATION public API |
| CSceneImportTarget | EVENGINE_API_ORCHESTRATION public API |
| CSceneImportValue | Renderer-neutral persisted scene importer settings |
| ►Nscheduling | |
| CEventMetadata | Sequence and explanation shared by queue lifecycle events |
| CItemMetadata | Identity, priority and terminal explanation shared by scheduled items |
| ►Nschema | |
| CFieldDefinition | Metadata and validation constraints for one object member |
| CSchema | Script-facing facade for runtime schema registration and validation |
| CSchemaCompatibility | The exact compatibility path selected by SchemaRegistry |
| CSchemaDefinition | Versioned runtime schema for a JSON object |
| CSchemaNode | Recursive node in the deliberately small Eve Schema language |
| CSchemaRegistry | Process-wide registry for runtime gameplay schemas |
| CValidationError | One machine-readable validation failure |
| ►Nscript | |
| ►Ndetail | |
| CRuntimeSlotCoordinates | Slot coordinates without the domain tag |
| CRuntimeSlotStore | Tag-free slot store behind every RuntimeObjectRegistry<T, Tag> |
| CBindContext | Pins the active VM and a stable diagnostic source for one expose() TU |
| CBindingContract | Complete script-facing contract for a native function or method |
| CBindingContractRegistry | Registry consumed by compiler checks and tooling protocol adapters |
| CBindingParameterContract | One native binding parameter visible to EveScript tools and named arguments |
| CBindingSearchHit | Ranked Binding Contract hit from text search |
| CBorrowed | Non-owning C++ observation with no implicit lifetime extension |
| CBorrowedSquirrelObject | Borrowed view of a rooted Squirrel object for one synchronous call |
| CIScriptModuleProvider | Pluggable script source backend for directories, archives, plugins, or memory |
| CISquirrelRootReleaser | Releases C++-owned Squirrel roots before Runtime destroys its VM |
| COwnedSquirrelObject | A rooted Squirrel reference owned by the C++ holder |
| CRuntimeHandleRef | Handle plus owner-lifetime epoch for a non-ECS registry object |
| CRuntimeObjectRegistry | Slot/generation registry whose objects are exclusively unique-owned |
| CRuntimePin | RAII keep-alive for one RuntimeObjectRegistry entry |
| CScriptCompiler | Unified Runtime compiler facade for metadata, diagnostics, and module preparation |
| CScriptCompletion | Tool-neutral completion item suitable for LSP, MCP, and editor adapters |
| CScriptDiagnostic | Stable structured diagnostic shared by Runtime, LSP, MCP, and editor tools |
| CScriptErrorContext | Structured snapshot of a script error: message, throw site and stack |
| CScriptFrame | One call-stack frame captured while the script error is still live |
| CScriptHover | Tool-neutral hover result for one script or binding symbol |
| CScriptMetadata | Metadata retained for one compiled EveScript source unit |
| CScriptModuleRequest | Logical module request emitted by an EveScript import declaration |
| ►CScriptModuleResolver | Owns providers, the static dependency graph, compiled closures, and module instances |
| ►CImpl | |
| CModule | |
| CProviderEntry | |
| CScriptModuleSource | UTF-8 source and stable identity returned by a module provider |
| CScriptPropertyMetadata | Inspector-facing metadata for one annotated script property |
| CScriptSourceMap | Source map for a compiled script |
| CScriptSourceMapEntry | One generated-to-original mapping segment. Native syntax uses identity mappings |
| CScriptSourcePosition | Original EveScript source position. Lines and columns are one-based |
| CScriptSymbolMetadata | Erased source-level symbol retained for tooling |
| CSquirrelValueOptions | Limits and provenance used by the Squirrel ↔ Value adapter |
| ►Nsensing | |
| CCandidate | A deterministic candidate returned by a spatial query |
| CCandidateQueryResult | Owning ranked result; does not assign a primary target |
| CGridArea | An integer grid area constraint, kept separate from WorldArea |
| CGridPoint | Integer grid point tagged as Grid2D or Grid3D |
| CILineOfSightQuery | Consumer-owned line-of-sight capability |
| CISensingCandidateProvider | Candidate discovery capability consumed by TargetingResolver |
| CITargetingTask | Pluggable Select/Filter/Sort task |
| CLineOfSightResult | Result of one injected line-of-sight query |
| CLineOfSightRouter | Routes each line-of-sight query to the backend that claimed its coordinate space |
| CPerceptionFact | Neutral perception fact projected from a ranked sensing candidate |
| CQueryBox | Inclusive axis-aligned box shape for QuerySpec (World2D) |
| CQueryCircle | Circle shape for QuerySpec (World2D) |
| CQueryCone | 2D cone/sector shape for QuerySpec (World2D) |
| CQueryOrigin | World2D origin used for range tests and distance sorting |
| CQuerySpec | Configurable candidate query against SensingWorld |
| CRankedCandidate | One ranked candidate produced by SensingWorld::query |
| CScriptSensingWorld | |
| CSensing | Script factory for independent sensing worlds |
| CSensingCandidateProvider | Pure CPU sensing candidate provider with deterministic map-backed storage |
| CSensingWorld | Gameplay-facing 2D candidate query service; it never values or selects targets |
| CSensingWorldCandidateProvider | ISensingCandidateProvider adapter over a SensingWorld fact mirror |
| CSensingWorldHandleTag | Handle domain for module-owned sensing worlds |
| CSubject | Mirrored gameplay facts used by candidate queries |
| CTargetCandidate | Candidate facts returned by sensing |
| CTargetingPipeline | In-memory task + preset registry and synchronous executor |
| CTargetingPreset | Named ordered list of targeting tasks |
| CTargetingQuery | A query passed from a domain targeting algorithm to sensing |
| CTargetingResolver | Generic constraint evaluator that composes candidate and LOS capabilities |
| CTargetingSourceContext | Runtime source for one pipeline execution |
| CTargetingSpec | A checked target-count and spatial constraint description |
| CTargetingTaskStep | Per-step parameters for a preset entry |
| CTargetSet | Owning target result containing primary-independent subjects and optional geometry |
| CWorldArea | A world-space area constraint |
| CWorldPoint | Finite world-space point tagged as either World2D or World3D |
| CZoneRef | Strong reference to a named spatial zone |
| ►Nservice | |
| CIFileSystem | Minimal file read / write / existence surface. Providers: eve::filesystem::Filesystem. Mocks can simulate missing files, read failures, and full disks without touching PhysFS |
| CIGpuTimer | Reads the GPU frame timing captured by the renderer via Vulkan timestamp queries. Providers: eve::graphics::Graphics |
| CINetwork | Minimal synchronous HTTP request surface. Providers: eve::network::Network. Mocks return canned status codes / errors, so consumers can test 404 / timeout / TLS paths without a network |
| CITimer | Monotonic elapsed-seconds clock. Providers: eve::timer::Timer. Mocks return scripted values so time-dependent logic can be tested deterministically |
| ►Nsettlement | |
| CISettlementPolicy | Domain-owned policy hooks used by the common settlement pipeline |
| CPreparedApply | Prepared domain mutation used to make settlement application atomic |
| CRuleFilter | Predicate selecting requests to which a rule applies |
| CSettlement | Factory module for script-owned settlement protocol runtimes |
| CSettlementBatchItemResult | Indexed owning outcome for one independently committed settlement item |
| CSettlementChainContext | Bounded trigger-chain metadata carried by an owning settlement request |
| CSettlementContext | Mutable calculation frame visible to policy and custom stage code |
| CSettlementPipeline | Deterministically ordered, composable settlement pipeline |
| CSettlementRandomDecision | Caller-owned deterministic random decision recorded for replay and verification |
| CSettlementRequest | Domain-neutral input to one settlement operation |
| CSettlementResult | Complete observable outcome of one successful settlement |
| CSettlementRule | One owning, serializable projection of a buff/effect contribution |
| CSettlementRuleSet | Validated immutable-style rule collection installable into pipelines |
| CSettlementStageResult | Explanation emitted for one executed stage |
| ►Nsocial | |
| CSocial | Script-facing module for generic social graph composition |
| CSocialChangeEvent | Immutable description of one social graph mutation |
| CSocialGraph | Indexed ownership, control, assignment, and typed-relation graph |
| ►Nsocial_editing | |
| CSocialDocumentTarget | UI-neutral revisioned social graph authoring document |
| CSocialEdgeRecord | Directed ownership, control, assignment or weighted relation edge |
| CSocialEntityRecord | Stable social-graph entity metadata for graph presenters |
| CSocialRuntimeApplier | Publishes a complete validated social document to a runtime SocialGraph |
| ►Nsound | |
| CDecoder | Streaming audio decoder (medialoader-backed). Owns the raw encoded bytes and decodes incrementally via decode(). Clones share immutable encoded storage and own independent playback positions. Each decoder is thread-affine; calls on one instance must be serialized |
| CSound | Sound module: decodes compressed audio and produces SoundData buffers. Script: sound <- eve.Sound(); |
| CSoundData | Raw PCM audio buffer with format metadata (samples/rate/bit depth/channels) |
| ►Nspatial | |
| CAABB2 | Axis-aligned 2D bounding box (min/max inclusive) |
| CAABB3 | Axis-aligned 3D bounding box (min/max inclusive) |
| CBSPTree2D | Binary space partition tree (kd-style AABB splits) for 2D culling. Alternating X/Y splits at node midplanes; spanning items stay on the node |
| CBSPTree3D | Binary space partition tree (kd-style AABB splits) for 3D culling. Alternating X/Y/Z splits at node midplanes |
| COctree | Region octree for 3D AABB broad-phase / scene culling. Same storage rules as QuadTree (smallest fully-containing node) |
| CQuadTree | Region quadtree for 2D AABB broad-phase / map culling. Items are stored in the smallest node that fully contains them; spanning items stay at the parent. Scripts use insert/remove/query* + getResult* |
| CQueryIds | Last-query hit buffer shared by spatial indexes. Script pattern: call query* → getResultCount / getResultId(i) |
| CSpatial | Spatial index module — broad-phase / map culling structures. Script: spatial <- eve.Spatial(); |
| CSpatialHash2D | Uniform-grid spatial hash for 2D AABB queries (map / particle / entity culling). Items are registered in every overlapped cell |
| CSpatialHash3D | Uniform-grid spatial hash for 3D AABB / sphere queries |
| ►Nspritestack | |
| CSliceInput | CPU triangle-mesh input used to bake horizontal RGBA sprite slices |
| CSliceOptions | Options for baking a mesh into equal-sized RGBA sprite layers |
| CSpriteStack | SpriteStack module: horizontal slice baking plus pure-2D rendering |
| CSpriteStack2D | Pure-2D sprite stack made from horizontal RGBA cross-sections |
| CSpriteStackBatch | Collection of 2D stacks; Graphics performs texture batching |
| ►Nspritestack_editing | |
| CISpriteStackModelResolver | Resolves model assets without coupling the document to AssetDB ownership |
| CSpriteStackAssetValue | Complete authored sprite-stack bake and presentation preset |
| CSpriteStackBakeRuntime | Candidate-first CPU baker and optional live SpriteStack2D publisher |
| CSpriteStackDocumentTarget | Revisioned SpriteStack bake preset with reusable Inspector metadata |
| CSpriteStackLayerArtifact | Metadata for one immutable baked layer |
| ►Nstate | |
| CIStateMutation | All-or-nothing mutation boundary owned by the consumer |
| CIStateQuery | Read-only world-state boundary owned by consumers such as Dialogue |
| CMutationContext | Correlation metadata shared by a mutation transaction |
| CMutationReceipt | Observable result of an all-or-nothing mutation request |
| CStateMutation | One immutable mutation request owned by its caller |
| ►Nstatepatch | |
| CChangeEvent | Immutable description of one committed value change |
| CPatchBatch | Ordered collection of set and remove operations committed atomically |
| CPatchBatchHandleTag | Handle domain for store-owned patch batches |
| CPatchError | One validation error produced while applying a patch batch |
| CPatchResult | Summary of the most recent batch commit attempt |
| CStateBatchHandleRef | A patch batch reference qualified by both its owning Store and batch slot |
| CStatePatch | Script module factory for generic state patch stores |
| CStatePatchStateAdapter | Adapts one persistent Store to state queries and transactional writes |
| CStateStoreHandleTag | Handle domain for module-owned state-patch stores |
| CStore | Deterministic subject-and-key JSON value store with atomic patching |
| CStoreTransactionParticipant | Transaction participant that atomically applies one StatePatch batch |
| ►Nstylize | |
| CAfterimageEffect | Fixed-rate owning transform history emitted as mesh-particle instances |
| CAfterimageEffectConfig | Fixed-rate model snapshot and fade controls for character afterimages |
| CAreaIndicatorBuildResult | Owning local-space mesh and terminal build status |
| CAreaIndicatorConfig | Geometry and edge-fade controls for one local-XZ area indicator |
| CAttackVfxBudget | Optional quality / budget knobs evaluated by later executor phases |
| CAttackVfxFrame | Owning result of one atomic orchestration step |
| CAttackVfxFrameEvent | Observable frame events emitted by advance/signal/stop |
| CAttackVfxHandle | Generation-qualified reference to one pooled attack VFX instance |
| CAttackVfxInstanceState | Owning observable state for one live instance |
| CAttackVfxLayer | One presentation layer slot inside a phase |
| CAttackVfxLayerHandle | Opaque executor-owned layer instance identity |
| CAttackVfxLayerStartRequest | Borrowed start context for one layer inside an entering phase |
| CAttackVfxPalette | RGB palette used as a skin tint (components in [0, 1]) |
| CAttackVfxPhase | One timeline phase that owns zero or more layers |
| CAttackVfxPhaseState | Live observation of one phase inside an instance |
| CAttackVfxRecipe | Versioned attack VFX composition recipe |
| CAttackVfxRecipeSlot | Transactional hot-reload boundary for one attack VFX recipe. A failed reload preserves both the previous recipe and revision |
| CAttackVfxRequest | Owning play request |
| ►CAttackVfxRuntime | Deterministic pooled runtime for AttackVfxRecipe instances |
| ►CImpl | |
| CLiveLayer | |
| CLivePhase | |
| CSlot | |
| CAttackVfxSkin | Reusable elemental / style skin applied at play time |
| CAttackVfxSpatial | Backend-neutral spatial binding stored on a layer |
| CAttackVfxVec3 | Owning three-component float used at the recipe boundary |
| CBeamBuildResult | Owning beam generation result suitable for MeshEffectRenderer::submitTrail |
| CBeamEffectConfig | Shape and deterministic noise controls for one 3D beam or lightning arc |
| CBeamSkillEffect | Gameplay-facing recipe for laser and lightning mesh effects |
| CIAttackVfxLayerExecutor | Optional open backend for one AttackVfxLayerRole |
| CIMeshVfxBatchSink | Immediate graphics-backend contract for a mesh VFX render queue |
| CMeshEffectDrawSource | Immediate borrowed inputs for drawing an effect over an existing mesh |
| CMeshEffectInstance | Runtime state for a shader effect attached to a renderable mesh |
| CMeshEffectPlayback | Deterministic timing configuration for one mesh effect playback |
| CMeshEffectRenderer | Render-thread adapter from stylize runtime state to Graphics mesh draws |
| CMeshParticleAdvanceReport | Observable result of advancing one mesh-particle emitter |
| CMeshParticleBurst | One repeatable emission event on an emitter timeline |
| CMeshParticleColorKey | One normalized-time color key used by mesh-particle gradients |
| CMeshParticleDrawSource | Borrowed mesh/material plus owning transform state for one mesh particle draw |
| ►CMeshParticleEmitter | CPU-authoritative deterministic 3D mesh-particle emitter |
| CParticle | |
| CMeshParticleEmitterConfig | Deterministic simulation and emission settings for a 3D mesh emitter |
| CMeshParticleInstance | Render-facing immutable state of one live mesh particle |
| CMeshParticleRenderInputs | Complete planner and renderer inputs generated from one particle snapshot |
| CMeshParticleScalarKey | One normalized-time scalar key used by mesh-particle lifetime curves |
| CMeshVfxAnimationDispatch | Summary of lifecycle actions dispatched from one animation event batch |
| CMeshVfxAnimationTriggers | Animation notification names mapped to built-in Mesh VFX lifecycle actions |
| CMeshVfxAsset | Versioned, backend-neutral description of a real-time mesh effect |
| CMeshVfxAssetInstance | Owning runtime instantiated from one immutable MeshVfxAsset snapshot. @ownership Owns all layer runtimes and the optional trail; target meshes remain borrowed by renderer resolution. @thread Simulation-thread affine. Rendering must consume layers on the render thread. @reentrancy Does not invoke callbacks |
| CMeshVfxAssetSlot | Transactional hot-reload boundary for one mesh VFX asset. A failed reload preserves both the previous asset and revision. Filesystem watching belongs to the caller. @thread Affine to the owning asset/editor thread; no internal synchronization |
| CMeshVfxBatchedDraw | One ordered draw reference inside a render batch |
| CMeshVfxBatchExecutor | Executes a planned render queue against one immediate backend sink |
| CMeshVfxBatchKey | Immutable GPU-state identity used to combine compatible draw items |
| CMeshVfxBatchStats | Summary of rejected or accepted queue entries |
| CMeshVfxEventAsset | Named gameplay/render marker on the primary layer's normalized playback timeline |
| CMeshVfxFloatCurve | Piecewise-linear parameter animation evaluated over one playback cycle |
| CMeshVfxFloatKey | One normalized key in a deterministic float parameter curve |
| CMeshVfxLayerAsset | One independently rendered layer in a mesh VFX asset |
| CMeshVfxLodCandidate | View-dependent input used to prioritize one mesh VFX instance |
| CMeshVfxLodDecision | Deterministic rendering decision for one input candidate |
| CMeshVfxRenderBatch | Consecutive compatible draws sharing GPU state |
| CMeshVfxRenderBatchPlanner | Builds deterministic state batches while preserving alpha depth order |
| CMeshVfxRendererCommand | Concrete draw payload resolved for one batched stable instance ID |
| CMeshVfxRenderItem | One visible mesh VFX draw before sorting and batching |
| CMeshVfxRenderQueue | Complete deterministic queue consumed by a graphics backend |
| CMeshVfxScalabilityPlanner | Selects mesh VFX quality under a deterministic per-view work budget |
| CMeshVfxScalabilityPolicy | Global deterministic quality and work budget for mesh VFX |
| CMeshVfxSubmissionReport | Counters and terminal state produced by queue execution |
| CMeshVfxTrailBinding | Authored root/tip attachment pair used to sample a weapon ribbon automatically |
| CMotionEchoAdvanceReport | Per-call observable sample and expiration counters |
| CProjectileTrailConfig | Sampling, retention and ribbon appearance for a projectile trail |
| CProjectileTrailEffect | Time-resampled world-space trail for projectiles and dash effects |
| CSkillMeshEffect | Owning runtime composition for one common gameplay mesh effect |
| CStyleChain | Ordered multi-pass stylize pipeline (extension point) |
| CStyleDefinition | Immutable capability metadata for one built-in stylization recipe |
| CStyleInstance | Mutable parameter instance of an immutable built-in style definition |
| CStyleParameterDesc | Tooling metadata for one user-facing float parameter |
| CStylePass | One stylized post-process pass bound to a style id (built-in or custom label). Draws a full-quad of the source texture through a style fragment shader |
| CStyleRecipe | Compilable recipe of style instances sharing one pipeline stage |
| CStylize | Stylized / NPR rendering module — stable public surface for future expansion |
| CTrailEmitter | Deterministic CPU sampler and ribbon mesh generator for weapon trails |
| CTrailMeshSnapshot | Owning CPU snapshot suitable for upload by a graphics adapter |
| CTrailSample | One retained pair of weapon root/tip positions |
| CTrailSettings | Sampling and retention policy for a weapon ribbon trail |
| CTrailUploadData | Packed owning arrays accepted by Graphics dynamic mesh upload APIs |
| CTrailVertex | Backend-neutral vertex emitted by TrailEmitter |
| ►Nstylize_action | |
| CStylizeAction | Composition entry for AttackVfx Action notify handlers and layer bridges |
| ►Nstylize_editing | |
| CMeshVfxAssetTarget | Transactional editor target for one canonical MeshVfxAsset document. @ownership Owns the authoritative asset snapshot; returned references are borrowed until mutation. @thread Editor-thread affine and not internally synchronized. @reentrancy Does not invoke callbacks |
| CMeshVfxPreviewRuntime | Candidate-first live preview generation for a MeshVfxAssetTarget. A rejected publication preserves the previous instance and revision |
| CStylizePassValue | Stable pass in an authored stylization recipe |
| CStylizeRecipeRuntime | Compiled, owned StyleRecipe generation used for live and offscreen preview |
| CStylizeRecipeTarget | Serializable ordered style recipe with dynamic parameter Inspector |
| ►Ntactics | |
| CAbilityReceipt | One declared ability activation and the resource state it left behind |
| CAbilitySettlementRequest | Owning values required to settle one previously declared tactical ability |
| ►CBattle | Battle short-root and authoritative owner of board and turn state |
| CBoard | Authoritative board component |
| CCommands | Accepted external commands in deterministic sequence order |
| CEvents | Transient deterministic event projection; not a second state authority |
| CIdentity | Cold, persistent and authoritative battle identity |
| CObjectives | Authoritative objective definitions and completion state |
| CRandom | Battle-owned named random streams; previews never mutate this component |
| CRandomStreamState | One named deterministic random stream's serializable state |
| CReactions | Authoritative transient reaction stack and root-chain cycle guard |
| CTurnState | Authoritative deterministic lifecycle and scheduling state |
| CBattleCommand | One accepted replay command using only persistent identities and values |
| CBattleEvent | One deterministic battle lifecycle event owned by Battle |
| CBattleReplay | Replays accepted commands against an identity-compatible starting battle |
| CBattleSystem | Stateless systems over the tactics short-root ECS family |
| CBoardCellRecord | Owning persistent board record used by snapshots and replay inspection |
| CBoardEdgeRecord | Owning persistent edge record used by snapshots and replay inspection |
| CBoardState | Authoritative board facts and occupancy indexes for one battle |
| CCell | Logical board coordinate independent of rendering projection |
| CCellState | One authoritative board cell fact |
| CChargeModel | The charge rule a policy declares for round scheduling |
| CEdgeState | One authoritative directed edge fact between two adjacent cells |
| CGridCoverPolicy | The built-in cover policy: blockers adjacent to the target, prioritising the line |
| CGridLineOfSightPolicy | The built-in grid policy: a straight-line trace over the board's own topology |
| CICoverPolicy | Answers "how much cover does @p target have against @p attacker" |
| CILineOfSightPolicy | Answers "can @p from see @p to" for one board |
| CInteractionContext | Immutable projection of everything the interaction machine is allowed to know |
| CInteractionIntent | One player intention, expressed with stable identities only |
| CInteractionSession | A disposable, non-authoritative interaction session |
| CITurnPolicy | One deterministic unit-activation ordering strategy |
| CMoveReceipt | Committed tactical movement and remaining resource state |
| CObjectiveSpec | Persistent objective definition using stable side identities |
| CObjectiveState | Mutable objective projection and completion revision |
| CPathQuery | Pure deterministic board path algorithms |
| CPresentationCommand | One intent together with the way to take it back |
| CPresentationFrame | What the projector knows about the battle beyond the event itself |
| CPresentationIntent | One presentation instruction: what to show, where, and until when |
| CPresentationProjector | Projects authoritative events into bounded, revertible presentation intents |
| CPresentationRevert | The explicit undo contract for one intent |
| CReachability | Owning result of one deterministic reachability query |
| CReachableCell | One reachable cell and its minimum fixed-point movement cost |
| CReactionCandidate | One eligible deterministic reaction choice |
| CReactionReceipt | Accepted reaction identity and remaining resource snapshot |
| CReactionWindow | One open reaction window on the battle-owned LIFO stack |
| ►CTacticalSide | Tactical side short-root entity |
| CIdentity | Cold, persistent and authoritative identity component |
| ►CTacticalUnit | Tactical unit short-root entity |
| CIdentity | Cold, persistent and authoritative identity component |
| CMembership | Linked battle and side identities; both are generation checked on use |
| CPosition | Hot authoritative tactical position and facing |
| CTurnResources | Hot authoritative per-turn resources |
| CTactics | Owns tactics short-root entities and coordinates checked battle setup |
| CTacticsActionExecutor | Active-effect provider that commits move, face and wait through ActionRuntime |
| CTacticsBattleSession | Module-owned script session referencing one battle aggregate |
| CTacticsBattleSessionTag | Owner tag for script-visible battle-session handles |
| CTacticsLineOfSightAdapter | Answers grid line-of-sight queries from the bound tactics battle |
| CTacticsPersistence | Stateless codec for the authoritative state of one battle |
| CTacticsSettlementRuntime | Owner-thread settlement bridge between tactics declarations and game-owned combat state |
| CTurnPolicyKind | Typed spelling of the built-in turn-policy ids |
| CTurnPolicyRegistry | Registry of turn policies keyed by stable id |
| CTurnResourceSpec | Initial and per-round tactical resource values for one unit |
| CUnitOrder | The scheduling projection a policy is allowed to compare |
| ►Ntags | |
| CGameplayTagDefinition | An owning gameplay-tag definition shared by runtime and editor tools |
| CGameplayTagRegistry | Canonical owner of versioned gameplay-tag definitions |
| CTagChangeEvent | Immutable description of one tag or capability mutation |
| CTags | Script-facing module for generic tags and capabilities |
| CTagStore | Deterministic storage for generic tags and capabilities |
| CTagStoreStateAdapter | Adapts one TagStore to read tags and apply volatile tag mutations |
| ►Ntensor | |
| ►Naffine | |
| ►Ndetail | |
| CConvExtent | ConvExtent public API |
| CByteView | Borrowed packed 8-bit values, valid for the duration of a synchronous call |
| CConvShape | Explicit 1D/2D NCHW convolution geometry; missing 1D height is one |
| CQuantizedActivation | ONNX unsigned activation quantization; owns bytes and scalar parameters |
| ►Nglsl_detail | |
| CChainContext | |
| ►Nonnx_detail | |
| CAttribute | Attribute public API |
| CByteStorage | ByteStorage public API |
| CCompiledProgram | CompiledProgram public API |
| CCompilerQueue | CompilerQueue public API |
| CFailure | Failure public API |
| CInput | Input public API |
| CModelData | ModelData public API |
| CNode | Node public API |
| CRuntimeTensor | RuntimeTensor public API |
| ►Nq | |
| CQuantPayload | QuantPayload public API |
| ►Nwgsl_detail | |
| CChainContext | |
| CCompiledFunction | Optimized / scheduled graph ready to run with feeds |
| CFunc | Trace builder — TF2 tf.function analogue (tf.func in scripts). While active, TF ops record into this graph |
| CFusedGroup | FusedGroup public API |
| ►CGpuProgram | GPU execution of a compiled tensor Graph via generated compute shaders |
| ►CImpl | |
| CGroupRuntime | |
| CGraph | EVENGINE_API_DOMAINS public API |
| CGraphNode | GraphNode public API |
| CKernelSpec | KernelSpec public API |
| COnnxBuffer | Immutable buffer shared by graph aliases; exactly one storage is authoritative |
| COnnxCompute | GPU execution boundary for native ONNX; retains no model and retains compiled resources for the lifetime of the provider |
| COnnxDeviceStorage | Run-scoped device storage. Readback completes pending work on the device thread |
| COnnxGpuResult | Owning GPU execution output and completed dispatch count |
| COnnxKernel | Synchronous GPU kernel request; all inputs are borrowed only until dispatch returns |
| ►COnnxModel | Native ONNX import and CPU/GPU execution using tensor kernels, without ONNX Runtime |
| CImpl | |
| COnnxModelInfo | Owning admission report; unsupported nodes remain inspectable but cannot execute |
| COnnxNamedTensor | Owning named feed/output value |
| COnnxRunOptions | Per-call deterministic RNG and optional strict finite-output diagnostic |
| COnnxTensor | Owning ONNX boundary tensor: row-major little-endian bytes and exact integer shape |
| COnnxTransferStats | Actual transfers and submissions made during one GPU run |
| COptimizedGraph | OptimizedGraph public API |
| CTensor | Float32 / int32 tensor (rank 1–6), row-major. Eager: owns a buffer. Symbolic: node in a Func graph (no buffer until run) |
| CTF | TF2-like namespace module. Script: tf <- eve.TF(); Default eager; tf.func() traces a graph for compile/run |
| ►Nthread | |
| CChannel | Thread-safe message queue (love2d-style Channel). Values are strings so the API stays overload-free for Squirrel bindings. Exposed to scripts as "ThreadChannel" (network already owns "Channel") |
| CJob | Handle to a single job inside a JobSystem |
| CJobSystem | Abstract job scheduler: dependencies, parallel_for, task_group, arena |
| ►CJobSystemThreadPool | Default JobSystem backend: a dependency-aware scheduler over the existing ThreadPool worker pool |
| CState | |
| CTask | A job executed by a ThreadPool worker. Status strings (no enums): "pending" | "running" | "done" | "failed" |
| CTaskGroup | Fork/join group: fork() spawns scheduled children, wait() joins them |
| CThread | Thread module: default pool, named channels, pool factory. Script: eve.Thread() → getPool / newThreadPool / getChannel / newChannel |
| ►CThreadPool | Fixed-size worker pool. Owns worker std::threads; tasks run FIFO. Squirrel VM is not thread-safe — do not call into scripts from workers |
| CState | |
| ►Ntilelayer_target | |
| CTileLayerTargetModule | Script-facing composition module for live tile-layer editing targets |
| ►Ntimer | |
| CTimer | High-resolution frame/elapsed timer backed by SDL_GetPerformanceCounter(). Script: timer <- eve.Timer(); |
| ►Ntouch | |
| ►Nsdl | |
| CTouch | SDL touch backend; touch state is updated from the event pump |
| ►CTouch | Active touch-point query interface (positions in window pixels) |
| CTouchInfo | One active contact; id is unique only for the duration of the press |
| ►Ntransaction | |
| CAtomicResourcePayment | Coordinates a resource debit with one domain effect participant |
| CCoordinator | Coordinates participant lifecycles with deterministic ordering |
| CEvent | Deterministically ordered transaction lifecycle event |
| CITransactionParticipant | Synchronous participant contract for one coordinator transaction |
| CLedger | Deterministic owner and identifier allocator for transaction plans |
| COperation | One inert, script-interpreted operation in a transaction plan |
| CPlan | Immutable-after-validation operation plan for script-coordinated work |
| CResourceDebitParticipant | Adapts IResourceAccount debit semantics to Coordinator |
| CTransaction | Script module factory for generic transaction ledgers |
| CTransactionContext | Immutable context shared by every participant of one transaction |
| CTransactionReceipt | Observable summary returned after an atomic participant commit |
| ►Nui | |
| CComponent | React-style UI component: implement build(), call setState / markDirty, then rebuild(). Mounts onto a named UIHost via mountAs / attach |
| CDatabasePanel | Reflection-driven database panel (DevTools, MVVM) |
| ►CEditorHost | Headless MCP editor host (MVVM) |
| CImpl | |
| CEditorShell | DevTools editor shell (main menu bar + docked panel layout) |
| CFlexItemSpec | FlexItemSpec public API |
| CFlexRect | FlexRect public API |
| CFlexResult | FlexResult public API |
| CGridItemSpec | GridItemSpec public API |
| CGridResult | GridResult public API |
| CImGuiBackend | Dear ImGui + SDL input + Vulkan present overlay |
| CInspector | Reflection-driven property inspector (DevTools phase C, MVVM) |
| CNinePatchInfo | Parsed Android-style .9.png stretch and content metadata |
| CObjectEntry | One registered live script instance |
| CObjectRegistry | Reflectable script-object registry backing the database panel |
| CParentScalerInput | Current canvas and target-list observation |
| CParentScalerOutput | Height write emitted for every valid target rect |
| CParentScalerSettings | Configuration for Pcg ParentScaler canvas-height behavior |
| CParentScalerState | Caller-owned change detector retained across evaluations |
| CPcgColorPreviewSync | Caller-owned highlighted-color snapshot ported from Pcg ColorPreviewSync |
| CPcgControllerSelection | Caller-owned visibility selection ported from Pcg UIControllerSelection |
| CPcgControllerTypeRow | One configured controller-description row from Pcg UIControllerType |
| CPcgDraggableWindow | Caller-owned state for Pcg's draggable photo-mode window |
| CPcgLoadingScreen | Caller-owned loading-screen state driven by Pcg terrain load-progress events |
| CPcgMissingTerrainScene | One missing Pcg terrain scene and the objects retaining its regular or impostor representation |
| CPcgPhotoModeApplyPlan | Stable, reversible difference between two complete Pcg photo-mode snapshots |
| CPcgPhotoModeColor | PcgPhotoModeColor public API |
| CPcgPhotoModeColorPicker | Caller-owned runtime model of Pcg PhotoModeColorPicker |
| CPcgPhotoModeField | PcgPhotoModeField public API |
| CPcgPhotoModePanelButton | Visual snapshot matching Pcg PhotoModePanelButton |
| CPcgPhotoModePanels | Seven-panel selection transaction used by Pcg photo mode |
| CPcgPhotoModePhotoAuthority | Explicit owner for Pcg's Photo domain fields |
| CPcgPhotoModePhotoState | PhotoMode-local capture, persistence and composition-overlay state |
| CPcgPhotoModeRange | PcgPhotoModeRange public API |
| CPcgPhotoModeRanges | Complete 57-range contract from Pcg PhotoModeMinAndMaxValues |
| CPcgPhotoModeRuntimeUI | Backend-neutral state of one Pcg PhotoModeUIHelper prefab instance |
| CPcgPhotoModeSession | Transactional lifecycle state for Pcg PhotoMode setup, disable and destroy |
| CPcgPhotoModeValues | Complete typed value set from Pcg PhotoModeProfile with exact defaults |
| CPcgScreenshotSavedNotice | Caller-owned notification state ported from Pcg ScreenshotSavedManager |
| CPcgScreenshotSize | Resolved screenshot dimensions; zero means the current drawable size |
| CPcgTooltipEntry | Stored Pcg tooltip profile row |
| CPcgTooltipManager | Caller-owned runtime model of Pcg Tooltip, TooltipManager, Profile and Trigger |
| CPropertyComponent | Component wrapper that becomes dirty when its bound model changes |
| CPropertyViewOptions | Policy controlling schema-to-widget generation for a UI shell |
| CScenePanel | Scene hierarchy panel (DevTools, MVVM) |
| CStyleClass | Sparse reusable widget style resolved once while a retained tree is built |
| CTheme | Unified UI design tokens (colors, geometry, typography). Applied to ImGui each frame via applyThemeToImGui; metrics are design-time units at uiScale=1 and are multiplied by the current UI scale |
| CThemeLayout | Semantic layout tokens shared by editor-oriented widgets |
| CUI | Declarative UI module (eve.UI) |
| CUIBackend | Platform / renderer backend for declarative UI. Concrete implementations live under ui/<backend>/ (e.g. ui/imgui) |
| CUIChange | Value/text/toggle change for script: "hostName/nodeId" |
| CUIClick | One script-facing click: "hostName/nodeId" |
| CUIDrop | One completed desktop drop with no borrowed node or platform pointers |
| CUIEvent | UIEvent public API |
| ►CUIHost | ECS mount point for one UI panel/screen. Subclass to attach UI to game entities, e.g. class Hud : public UIHost. UISystem walks ecs::View<UIHost, Meta, Tree> (includes subclasses) |
| CMeta | Meta public API |
| CTree | |
| CWorldAnchor | Optional 3D-world projection for this UI host |
| CUiHostOverlayAlphaSink | Pushes float samples into a host overlay background alpha. @ownership Does not own the host; resolves host on every write |
| CUiHostPosSink | Pushes MotionVec2 samples into a host window position (Meta.posX/Y). @ownership Does not own the host; resolves host on every write |
| CUiHostSizeSink | Pushes MotionVec2 samples into a host explicit size (Meta.sizeX/Y). @ownership Does not own the host; resolves host on every write |
| CUiHostTween | One host-level tween slot |
| CUiItemTween | One item-level tween slot scoped to a host + node id |
| CUINode | Retained UI widget node (arena tree). Conceptual counterpart of eve::scene::SceneNode; built declaratively from WidgetDesc |
| CUiNodeOpacitySink | Pushes float samples into a retained node's transient opacity. @ownership Does not own the host/node; resolves both on every write |
| CUiNodePosSink | Pushes MotionVec2 samples into a node's absolute placement offset. @ownership Does not own the host/node; resolves both on every write |
| CUiObjectHandleTag | Owner tag for UI database object handles |
| CUIStats | UIStats public API |
| CUISystem | EVENGINE_API_WORLD public API |
| CUiTweenDriver | Owns pending UI tweens and advances them against an injected clock. @ownership UI owns one driver; handles are generation-checked via UIHost::resolve |
| CViewportState | ViewportState public API |
| CWidgetDesc | Declarative widget description (build once / on dirty → flatten into UIHost::Tree) |
| CWorldAnchorLayoutItem | One projected host participating in deterministic screen-space placement |
| CWorldAnchorLayoutResult | Owning placement result corresponding to WorldAnchorLayoutItem::stableIndex |
| CWorldAnchorProjection | Immutable result of projecting a UI world anchor into a viewport |
| ►Nui_editing | |
| CCreateUiWidgetRequest | Request for creating one widget with stable identity |
| CIUiDocumentEditTarget | Hierarchy/layout capability consumed by UI tree and canvas tools |
| CUiContentValue | Renderer-neutral text and image skin authored per widget |
| CUiDocumentPreviewService | UI-neutral preview, picking and anchor-gizmo geometry service |
| CUiDocumentRuntimeBridge | Optional bridge publishing a UI document into a real runtime UIHost |
| CUiDocumentTarget | Serializable UI authoring document with hierarchy and inspector capabilities |
| CUiLayoutValue | Renderer-neutral layout values shared by UI document hosts |
| CUiPreviewSnapshot | Deterministic UI layout preview used by canvas rendering and picking |
| CUiPreviewWidget | Computed widget rectangle in a revision-bound UI preview |
| CUiStyleValue | Renderer-neutral visual and box-model style authored per widget |
| CUiThemeAsset | One named, fully snapshotted Theme asset |
| CUiThemeCatalogTarget | Serializable catalog of named UI themes with one active publication slot |
| CUiThemePreviewService | Builds a Theme copy for a catalog revision without touching runtime globals |
| CUiThemePreviewSnapshot | Revision-bound Theme copy used by gallery hosts without mutating globalTheme |
| CUiThemeRuntimePublisher | Publishes the active catalog theme through ui::setGlobalTheme |
| CUiWidgetSnapshot | Immutable widget snapshot used across editor/runtime boundaries |
| ►Nui_editor | |
| CUiEditorModule | Composition adapter that exposes the script-owned UiThemeEditor factory |
| CUiThemeEditor | Workspace controller for one authored UI theme catalog |
| ►Nvehicle | 驾驶者接口与玩家控制状态。 |
| CArmorZone | 装甲区（Phase 4 伤害管线使用；Phase 2 仅作为定义数据保留）。 |
| CIVehicleDamageModifier | 伤害修饰器（游戏侧注册，多重监听，按优先级调用）。 |
| CIVehicleDriver | 驾驶者：把某乘客的控制转成载具输入。 |
| CIVehicleMobility | 移动模型：读输入、更新运动状态。 |
| CMountDef | 武器挂点声明（载具模板的一部分）。 |
| CPlayerControl | 一名玩家的原始控制（归一化，游戏侧填充）。角度为度。 |
| CSeatDef | 座位声明（载具模板的一部分，FPS 面）。 |
| CSuspensionConfig | 3D 悬架参数（车辆模板的一部分）。 |
| CSuspensionWheel | 3D 悬架车轮配置（raycast 悬架用）。 |
| CVehicle | 载具模块（eve.Vehicle）。 |
| CVehicleAttributeAdapter | Adapts VehicleEntity health and armor to the common attribute core |
| CVehicleDefinition | 载具模板（registerVehiclesFromJson 注册，进程级注册表）。 |
| CVehicleDefinitionRuntime | Binds a VehicleDefinition to a VehicleEntity without a new root type |
| CVehicleEffectAdapter | Vehicle adapter with one common container and one typed executor |
| CVehicleEffectDefinition | Strong vehicle definition projected into the common lifecycle |
| CVehicleEffectExecutor | Vehicle executor applying armor-zone and disable strategies |
| CVehicleEffectSnapshot | In-memory vehicle effect snapshot |
| CVehicleEffectTarget | Mutable vehicle state changed by the effect executor |
| CVehicleEffectUpdate | Result of one vehicle lifecycle step and armor settlement |
| ►CVehicleEntity | 载具实体：数据全部在组件里，行为在 VehicleSystem。 |
| CAttributes | Canonical selected combat attributes for this vehicle |
| CDefinition | 模板指针（Vehicle 模块注册表持有，实体不拥有）。 |
| CDefinitionBinding | Canonical definition identity projected onto this ECS entity |
| CFlags | 通用标志位。 |
| CHealth | 生命值（Phase 4 伤害管线增强）。 |
| CIdentity | 稳定实例 id / 模板 id / 阵营。 |
| CInput | 每帧输入（命令系统 / 驾驶者写入，移动模型消费）。 |
| CMotion | 2D 运动状态（kinematic 直接持有；物理模式由 body 回写）。 |
| CMounts | 武器挂点槽位列表（不拥有挂点；weapon 模块管理生命周期）。 |
| CMountSlot | 一个挂点槽位：挂点实体 + 瞄准模式。 |
| COrders | Vehicle order lifecycle adapter and compatibility projection |
| CPhysicsBody | 跨帧物理绑定；不透明实现持有 generation link 和弱 world 生命周期。 |
| CSeats | 座位列表（FPS 面）。 |
| CSeatSlot | 座位槽位（运行时，与模板 seats 一一对应）。 |
| ►CSuspensionState | 悬架运行时状态（与模板 wheels 一一对应）。 |
| CWheelState | WheelState public API |
| CVehicleEvent | 载具事件（帧缓存，脚本轮询）。 |
| CVehicleInput | 每帧驾驶输入（由 PlayerDriver / OrderSystem / 脚本写入）。 |
| CVehicleOrder | 一条 Vehicle 领域命令（生命周期由 Vehicle order adapter 执行）。 |
| ►CVehicleOrderQueueAdapter | Maps VehicleOrder domain payloads onto an orders::CommandQueue |
| CImpl | |
| CVehiclePhysics | VehiclePhysics public API |
| CVehiclePhysicsBinding | |
| CVehicleRuntimeState | Mutable state owned by one typed vehicle runtime instance |
| ►CVehicleSeatContainerAdapter | Transactional adapter over one VehicleEntity::Seats component |
| CPreparedState | |
| CVehicleSeatContainerObject | Owning snapshot payload for a vehicle occupant membership |
| CVehicleSettlementAdapter | Settles damage/healing against one VehicleEntity |
| CVehicleSystem | 载具系统：移动注册 + 命令处理 + 更新。 |
| ►Nvirtualgeometry | |
| ►Nvulkan | |
| CVgState | |
| ►Nwebgpu | |
| CVgState | |
| CVgBackend | Opaque backend state for one virtual-geometry renderer. Owned by VirtualGeometryRenderer; allocated/freed by the active backend |
| CVgCluster | CPU-side processed cluster (before packing into VgGpuCluster) |
| CVgGpuCluster | GPU-mirrored cluster node layout (std430, matches shaders/vg_*.comp). Exactly 4 x uvec4 per cluster: |
| CVgUniforms | VgUniforms public API |
| CVirtualGeometry | Virtual-geometry module — Nanite-style virtualized geometry rendering on top of the active Graphics backend (Vulkan). See docs/dev/VIRTUAL_GEOMETRY.md |
| CVirtualGeometryAsset | Fully processed virtual-geometry asset (CPU representation). Produced by Builder from a Mesh; uploaded to GPU SSBOs by the backend |
| ►CVirtualGeometryBuilder | CPU preprocessor that builds a Nanite-style hierarchical cluster DAG from a triangle mesh: |
| CMeshInput | MeshInput public API |
| COptions | |
| CVirtualGeometryRenderer | A virtual-geometry renderer: preprocesses a mesh into a cluster DAG, uploads it to the GPU, then each frame runs GPU-driven culling + a software rasterizer into a visibility buffer |
| ►Nvirtualgeometry_editing | |
| CIVirtualGeometryMeshResolver | Asset resolver boundary for VirtualGeometry preprocessing |
| CVirtualGeometryBuildArtifact | Immutable quality/cost report for a built virtual-geometry generation |
| CVirtualGeometryBuildRuntime | Candidate-first CPU cluster-DAG builder and LOD preview service |
| CVirtualGeometryDocumentTarget | Revisioned VirtualGeometry importer preset |
| CVirtualGeometryImportValue | Authored virtual-geometry import and LOD-preview settings |
| CVirtualGeometryLodSample | One sample in the logarithmic camera-distance LOD cost curve |
| CVirtualGeometryMeshData | Owned neutral triangle mesh supplied by an importer/AssetDB adapter |
| ►Nvoxel | 方块类型定义：名字、各面图集纹理、方向性、组合声明。 方向性方块在注册时按 orientation 绕 Y 轴展开成多个"具体类型"变体， 每个变体持有旋转后的各面纹理；渲染端只消费纹理 id，不接触 orientation。 |
| CChunk | One 32³ voxel chunk with six direction-sorted packed-rect instance buffers. Coordinates: chunk (cx,cy,cz) → world origin (cx*32, cy*32, cz*32) |
| CCubeType | CubeType public API |
| CCubeTypeRegistry | EVENGINE_API_DOMAINS public API |
| CDecodedRect | One decoded face rectangle in world space (mirrors voxel_rect.vert) |
| CDrawBatch | One draw batch: all packed rects of one face direction for one chunk |
| CFrustum | Six frustum planes in ax+by+cz+d >= 0 form (normals point inward) |
| CGreedyMesher | Greedy rectangle mesher for one 32³ dense voxel volume. Voxel storage: index = x + y*32 + z*32*32. Value 0 = air; 1..255 = type id |
| CPackedRect | Packed face-rectangle instance (exactly 32 bits): bits 0..4 : x (0..31) bits 5..9 : y (0..31) bits 10..14 : z (0..31) bits 15..19 : width - 1 (0..31 → size 1..32) bits 20..24 : height - 1 (0..31 → size 1..32) bits 25..31 : texture index (0..127) |
| CStreamStats | Result of a streaming pass |
| CVoxel | High-performance voxel rendering module |
| CVoxelWorld | Sparse chunk map + visibility selection (frustum + distance + face orientation). Meshing is neighbor-aware (cross-chunk seam culling), parallel-capable and script-friendly via getVisible getters and raycast helpers |
| ►Nvoxel_editing | |
| CVoxelCatalogTarget | Revisioned project of MagicaVoxel-style sculpted models |
| CVoxelCoord | One occupied cell inside a sculpted model |
| CVoxelModelValue | One MagicaVoxel-style object: a bounded occupancy grid |
| CVoxelPaletteEntryValue | Stable authored entry in a Voxel cube palette |
| CVoxelPalettePublishedEntry | Stable base/variant ID mapping produced by palette publication |
| CVoxelPaletteRuntime | Candidate-first CubeTypeRegistry publication |
| CVoxelPaletteTarget | Revisioned Voxel CubeType palette with face-material Inspector |
| CVoxelPick | DDA pick against a sculpted model |
| CVoxelSocket | One face socket: matching tag plus compatible polarity |
| CVoxelWorldTarget | Non-owning authoring adapter from a live voxel world to the volume protocol |
| ►Nvoxel_editor | |
| CVoxelCatalogEditor | Workspace controller for a MagicaVoxel-style voxel sculpt project |
| ►CVoxelEditorModule | Composition adapter that contributes MagicaVoxel-style sculpt commands and automation targets |
| CTargetFactory | |
| ►Nvoxelworld_target | |
| CVoxelWorldTargetModule | Script-facing composition module for live voxel-world editing targets |
| ►Nweapon | 载具模块入口（eve.Vehicle）：定义注册 / 实体工厂 / RTS 命令 / 帧调度。 设计文档：docs/dev/通用载具系统设计.md |
| ►CAmmoPoolEntity | 共享弹药池实体：多把武器共用的备用弹药，装填时从池中取。 |
| CIdentity | 弹药池 id / 弹药类型（"pistol" | "rifle" | "shell"…）。 |
| CState | 当前存量 / 上限（<0 = 无限）。 |
| CAttackRequest | 一次攻击请求（C++ 系统 / 脚本发起）。角度均为度。 旧名 FireRequest 保留为别名，向后兼容。 |
| CAttackResource | 触发资源模板（武器模板的一部分，用于运行时扣费 / 回复）。 |
| CAttackStageSpec | 阶段时长（秒）；各形态按需配置。 |
| CCarrierBodyDefenseSample | One body/shield sample used by SteerAvoidBody to curve around defenses |
| CCarrierChildSpawn | Deferred child spawn recorded during update |
| CCarrierEvent | Owning event emitted by an impact |
| CCarrierFrame | Owning result of one atomic carrier simulation step |
| CCarrierHandle | Generation-qualified reference to one pooled carrier slot |
| CCarrierImpact | One impact bound to a trigger kind |
| CCarrierMotion | Live motion snapshot for one carrier |
| CCarrierMotionOp | One ballistic operator plus its parameters |
| CCarrierRecipe | Data-driven composition recipe for one carrier family |
| CCarrierRuntimeSnapshot | Complete deterministic carrier-pool state for rollback/save |
| CCarrierSlotSnapshot | One pool slot including generation, retained while empty |
| CCarrierSpawnRequest | Owning spawn request |
| CCarrierState | Owning observable state for one live carrier |
| CCarrierTrigger | One trigger specification |
| CCarrierVolleySpec | Deterministic multi-direction spawn descriptor |
| CCombatCarrierRuntime | Owner-thread deterministic carrier simulator with composable behaviors |
| CICarrierBodyDefenseProvider | Optional body/shield boundary for SteerAvoidBody |
| ►CICarrierHitProbe | Optional swept-hit boundary used only by OnHit triggers |
| CContact | Owning contact reported between previous and current motion |
| CIProjectileService | 投射物服务：由游戏侧实现并注册为能力。 weapon 模块只认识这个接口，弹道/爆炸/受击由提供方负责。 |
| CIProjectileTargetProvider | Optional target-position boundary used only by homing projectiles |
| CIWeaponLogic | 武器逻辑接口：注册到 WeaponSystem 的可插拔行为。 |
| CProjectileDefinition | Data-driven trajectory and lifetime definition |
| CProjectileHandle | Generation-qualified reference to one pooled projectile slot |
| CProjectilePoint | Owning point in projectile simulation space |
| CProjectileRuntime | Owner-thread deterministic projectile simulator with a bounded reusable pool |
| CProjectileRuntimeSnapshot | Complete deterministic projectile-pool state for rollback and save games |
| CProjectileSlotSnapshot | One pool slot including its generation, retained even while empty |
| CProjectileSpawnRequest | Owning spawn request; homing requests require a generation-checked target |
| CProjectileSpec | 投射物参数（武器模板的一部分，供游戏侧投射物服务使用）。 |
| CProjectileState | Owning observable state for one live projectile |
| CProjectileUpdate | Owning result of one atomic projectile simulation step |
| CProjectileVector | Owning velocity or direction vector in projectile simulation space |
| CResource | 运行时触发资源（实体组件）。 |
| CSpellCastPlan | One compiled cast unit ready to register and spawn |
| CWeapon | 武器模块（eve.Weapon）。 |
| CWeaponActionAdapter | Translates a WeaponDefinition/AttackRequest pair to Action values |
| CWeaponAttributeAdapter | Adapts only Mana/Stamina trigger resources to AttributeProjection |
| CWeaponControl | Exposes one weapon through the shared gameplay command protocol |
| CWeaponDefinition | 武器模板（registerWeaponsFromJson 注册，进程级注册表）。 |
| CWeaponDefinitionRuntime | Binds a typed WeaponDefinition to one mutable runtime instance |
| CWeaponEffectAdapter | Weapon adapter with a single common lifecycle owner |
| CWeaponEffectDefinition | Typed weapon definition projected into the common lifecycle |
| CWeaponEffectExecutor | Weapon executor applying heat, jam and recoil rules |
| CWeaponEffectSnapshot | In-memory weapon effect snapshot |
| CWeaponEffectTarget | Mutable weapon state interpreted by the typed executor |
| CWeaponEffectUpdate | Result of one weapon lifecycle step and domain settlement |
| ►CWeaponEntity | 武器实体：数据全部在组件里，行为在 WeaponSystem。 |
| CAim | 炮口朝向（度）。turnSpeed 0 = 立即到位。 |
| CAttributes | Canonical optional mana/stamina state for non-ammo weapons |
| CDefinition | Typed definition projection used by legacy WeaponSystem code. @ownership Borrowed through def when owned is empty. When owned is present, this component owns the immutable projection and def points into it. @lifetime The borrowed pointer remains valid until this component is replaced or its owner is destroyed. Callers must not retain it across a definition projection swap |
| CDefinitionBinding | Canonical definition identity and reload policy projected to ECS. @ownership The common DefinitionRegistry owns definition data; this component only stores identity and policy. @lifetime The identity is valid with this entity and becomes stale when the registry generation is replaced or removed |
| CIdentity | 稳定实例 id / 模板 id / 游戏侧拥有者。 |
| CState | 触发资源 / 冷却 / 装填 / 阶段机运行时状态。 |
| CWeaponEvent | 武器事件（帧缓存，脚本轮询，与 building/rpg 风格一致）。 |
| ►CWeaponMountEntity | 武器挂点实体：可持有武器并限制旋转（炮塔 / 机枪座 / 固定挂架）。 |
| CIdentity | 挂点 id / 场景节点路径 / 类型（"turret" | "pintle" | "fixed"）。 |
| CLimits | 旋转限位与射界（度）。 |
| CState | 当前朝向（度）与挂载的武器（不拥有，模块负责两者生命周期）。 |
| ►CWeaponRigEntity | 手持位实体：面向 ARPG/RPG 角色手持武器（剑/法杖/步枪），无炮塔限位。 |
| CHeld | 持有位姿偏移（挂到角色手持节点的相对位置/旋转）。 |
| CIdentity | 手持位 id / 场景节点路径 / 握持类型。 |
| CState | 当前持有的武器（不拥有，模块负责生命周期）。 |
| CWeaponRuntimeState | Mutable state owned by one typed weapon runtime instance |
| CWeaponSystem | 武器系统：逻辑注册 + 更新 + 开火 + 装填。 |
| ►Nweather | |
| CPcgInteriorWeatherVolume | Caller-owned, immutable-after-configuration Pcg interior-weather volume. @ownership This value owns all configuration; Weather copies sampled state and never retains this object. @thread Affine to the caller; configure and sample must not overlap. @reentrancy Does not invoke callbacks |
| CSnow | Interactive snow service owned by the weather module |
| CSnowField | Interactive snow depth field: a dense [0,1] float grid |
| CThunderStrikeReceipt | Deterministic strike command consumed by scene, light and audio providers |
| CThunderStrikeSettings | Pcg ThunderStrike parameters independent of renderer and audio providers |
| CThunderStrikeState | Caller-owned thunder flash state |
| ►CWeather | Weather module — real-time precipitation / lightning / wind system |
| CImpl | |
| ►Nwindow | |
| ►Nsdl | |
| CWindow | SDL2 desktop/mobile implementation of eve::window::Window |
| ►CWindow | Platform window interface (SDL implementation on desktop/mobile). Script: win <- eve.Window(); |
| CMessageBoxData | Parameters for a multi-button modal message box |
| CWindowSize | Logical width/height pair used by fullscreen size queries |
| CWindowSettings | Display settings for window creation/resize. width/height == 0 selects the desktop display mode size |
| ►Nxml | |
| CDocument | |
| CElement | |
| CNode | |
| CAssetRef | Stable asset identity backed by PersistentId |
| CAttachmentPoint | Plain world-space point shared by animation consumers without a math-library dependency |
| CCameraObstructionHit | Closest hit returned by the optional camera-obstruction provider |
| CData | Data public API |
| CDefinitionRef | Stable definition reference backed by LogicalId |
| CDiagnostic | A structured explanation of a failed, degraded, or noteworthy result |
| CDiagnosticValueTraits | Customization point for values that cross diagnostic boundaries |
| CDiagnosticValueTraits< DiagnosticCode > | DiagnosticValue mapping for machine-readable diagnostic codes |
| CDiagnosticValueTraits< ProtocolDispatch > | DiagnosticValue mapping for protocol dispatch outcomes |
| CDiagnosticValueTraits< Severity > | DiagnosticValue mapping for diagnostic severities |
| CDiagnosticValueTraits< StatusCode > | DiagnosticValue mapping for operation status categories |
| CDuration | Signed, fixed-resolution simulation duration in nanoseconds |
| CEntitySpatialPose | Renderer-neutral owning world pose resolved for an ECS entity |
| CException | EVENGINE_API_FOUNDATION public API |
| CGameplayActionDescriptor | One discoverable domain action and its owning schema projection |
| CGameplayCommand | One player-semantic command submitted to a domain authority |
| CGameplayCommandReceipt | Owning evidence that a gameplay authority accepted one command |
| CGameplayEvent | Owning event projection safe across frames and process boundaries |
| CGameplayObservation | Immutable owning observation of one authoritative gameplay instance |
| CGameplaySession | Owning authorization context shared by player, script and automation adapters |
| CGpuResidentBufferView | Transient backend buffer slice shared between sibling GPU modules. @ownership Non-owning; nativeHandle is never retained as an owning resource. @lifetime The producing buffer outlives all frame commands that consume this view. @thread Create and consume on the render/submission thread |
| CIAnimationEventSource | Read-only cross-module view of animation events emitted by the latest simulation update. @ownership Event names are returned by value; consumers retain no source storage. @thread Affine to the animation source's update thread. @reentrancy Implementations must not invoke callbacks |
| CIAttachmentPointSource | Read-only cross-module contract for sampling named animated attachment points. @ownership Implementations retain all pose data; returned points are values. @thread Calls are affine to the source's animation update thread. @reentrancy Implementations must not invoke callbacks |
| CIAudioQuery | Audio control surface (provided by the audio module) |
| CICameraObstructionQuery | Cross-module query used by camera without linking against physics |
| CIDecalQuery | Runtime decal query surface (provided by the decal module) |
| CIEditorAutomation | Module-neutral bridge from DevTools/MCP to the editor command protocol |
| CIEditorHost | Declarative editor-host control (provided by the ui module) |
| CIEmergenceActionHandler | Capability listener that may consume one emergence action kind |
| CIEntitySpatialProvider | One optional domain provider capable of resolving selected ECS entities |
| CIFramePacing | Host-loop frame pacing controlled independently of presentation |
| CIFramePresentation | Cross-module owner for swapchain presentation cadence |
| CIGameplayControlProvider | Multi-provider gameplay boundary consumed by input, scripts and automation |
| CIGameplayInstanceCatalog | Optional read-only discovery surface implemented beside a gameplay provider |
| CIMeshDeformationCompute | Optional synchronous device-thread service for mesh sculpt and damage compute |
| CIParticleSdfField | Borrowed 2D signed-distance field consumed by particle collision |
| CIParticlesQuery | Particle system query surface (provided by the particles module) |
| CIPhotoModeApplySink | IPhotoModeApplySink public API |
| CIPhotoModeFieldSink | IPhotoModeFieldSink public API |
| CIPhysicsQuery | 2D physics world query surface (provided by the physics module) |
| CIPixelWorldAutomation | Module-neutral JSON bridge from DevTools/MCP to PixelWorld tooling |
| CIProcgenProbeSink | Optional graphics consumer for complete generated probe batches. Implementations own all runtime resources and replace a batch atomically. Inputs are borrowed only for the call |
| CIProcgenQuery | Procedural generation query surface (provided by the procgen module) |
| CIProcgenSceneSink | Optional scene consumer for procedural instance batches |
| CIProcgenWorldQuery | Optional synchronous world-query capability for procedural generation |
| CIProfilerQuery | Runtime profiler read surface (provided by the profiler module) |
| CIRenderCapture | Frame capture + camera + visible-entity inspection (graphics) |
| CISceneQuery | Scene graph query/mutation surface (provided by the scene module) |
| CISensingQuery | Runtime sensing read surface (provided by the sensing module) |
| CISnapshotContentHasher | One content-digest implementation usable for snapshot sealing and verification |
| CITimeSource | Injectable source for elapsed and metadata time |
| CIUIAutomation | Semantic retained-UI automation provided by the ui module |
| CIWindowSurfaceHost | Render-surface host for the window module (provided by graphics) |
| CLogicalId | Human-readable, scoped identifier in the form namespace:name |
| CMeshDeformationComputeRequest | Owning, backend-neutral input for one synchronous GPU mesh deformation |
| CModule | EVENGINE_API_FOUNDATION public API |
| CModuleBindAccess | |
| ►CModuleManager | EVENGINE_API_FOUNDATION public API |
| CModuleInfo | ModuleInfo public API |
| CModuleRegister | EVENGINE_API_FOUNDATION public API |
| CMonotonicTimestamp | Timestamp from a monotonic source |
| CObjectRef | Stable world/object identity backed by PersistentId |
| CObserver | Thread-affine callback registry with mutation-safe dispatch |
| CPhotoModeAssignment | One reversible field assignment in a photo-mode transaction |
| CPhotoModeColor | RGBA payload used by the cross-module photo-mode application contract |
| CProcgenBatchSnapshot | One complete cell snapshot participating in an atomic multi-batch publication |
| CProcgenInstanceDelta | Identity-based, revision-checked mutation of one procedural scene batch |
| CProcgenInstanceDesc | Engine-neutral description of one procedural scene instance |
| CProcgenProbeDesc | Engine-neutral description of one generated reflection or light probe |
| CProcgenSurfaceHit | Value result for a procedural world-surface projection query |
| CRayHitInfo | Ray-cast result (value type) |
| CRect | Axis-aligned integer rectangle (screen/tile space) |
| CReflectedAttribute | EVENGINE_API_FOUNDATION_INLINE public API |
| CReflectedClass | EVENGINE_API_FOUNDATION_INLINE public API |
| CReflectedMember | EVENGINE_API_FOUNDATION public API |
| CReflectedValue | Typed snapshot of one live instance property |
| CRenderable3DInfo | Generation-qualified snapshot of one live field-backed Renderable3D |
| CRenderStatusInfo | Render surface / frame state snapshot (value type) |
| CResource | Resource is a game object that is managed by the ResourceManager. It can be loaded from a file or generated at runtime. If the resource is loaded from file, a monitor will be created to watch the file changes. When the file is modified, the resource will be reloaded. If the resource is generated at runtime, it can depend on a few other resources and the ResourceManager will update the resource when the dependencies are changed |
| ►CResourceManager | ResourceManager is a singleton that manages all resources in the game. It provides a way to load, reload, and unload resources |
| CAsyncLoad | AsyncLoad public API |
| CResourceRef | Type-safe union of the reference forms accepted by resource-facing APIs |
| CResourceUri | A semantically named resource locator |
| CResult | Move-only operation result carrying either a value or Status |
| CResult< void > | Move-only operation result for actions with no value payload |
| ►CRuntime | EVENGINE_API_FOUNDATION public API |
| CScope | Pushes this Runtime on the current thread's runtime stack |
| CScriptRecord | |
| CStackGuard | Restores the native Squirrel stack when a binding operation leaves scope |
| CRuntimeHandle | Process-local slot identity tagged by the registry that owns it |
| CSceneNodeInfo | Serializable snapshot of one scene node (value type, no scene types) |
| CScriptException | Exception raised at the public Runtime boundary |
| CScriptInfo | EVENGINE_API_FOUNDATION_INLINE public API |
| CSensingWorldQuery | Last completed query of one live sensing world |
| CSimulationClock | Owner-thread fixed-step scheduler driven by an injected time source |
| CSimulationStep | One deterministic fixed-step emitted by SimulationClock |
| CSnapshotEnvelope | Stable outer format shared by persistence and cross-process snapshots |
| CSnapshotMigrationChain | One directed payload migration step |
| CStartupStage | StartupStage public API |
| CStateValue | JSON-compatible state value tree used by state hot reload |
| CStatus | Structured status and zero or more diagnostics for an operation |
| CSubjectRef | Strong, domain-neutral reference to a runtime subject |
| CSubscription | Move-only RAII token that owns one observer registration |
| CUri | An immutable, canonical URI value |
| CUuidIdAdapter | UUID-backed identifier adapter for legacy textual boundaries |
| CUuidV7Generator | Injectable UUIDv7 generator |
| CValue | The canonical owning dynamic value used by data-facing protocols |
| ►CVersionedRegistry | A registry whose live values are qualified by a monotonically increasing runtime generation |
| CEntry | One stored key slot; absent value means the slot is a tombstone |
| CEvent | One canonical mutation event retained by the registry |
| CHandle | Generation-qualified identity of one live incarnation or tombstone |
| CState | Owning state image used for transactional snapshot/restore |
| CWallClockTimestamp | Wall-clock timestamp used only for metadata and diagnostics |
| ►Ngraphics_editing | |
| ►NGraphicsOffscreenPreviewService | |
| ►NImpl | |
| CArtifact | |
| CImpl | |
| ►Nstd | |
| Chash< eve::resource::ResourceId > | Hash public API |
| CMyFormatter |