Photon Quantum
3.0.0
| ►NExample | |
| ►NPhoton | |
| ►NDeterministic | |
| ►NProtocol | |
| CAddPlayer | This messages is send from the client to reserve a player slot |
| CAddPlayerFailed | This message is sent from the server when the AddPlayer request failed |
| CClockCorrect | Obsolete protocol message |
| CCommand | Creates a Quantum command |
| CDisconnect | Is sent from the server to gracefully disconnect a client |
| CFrameSnapshot | The client sends a snapshot of the game state to the server. The message is send multiple times if the snapshot is too large |
| CFrameSnapshotRequest | The server request a frame snapshot from the client |
| CGameResult | The client sends this message to report the game result |
| CMessage | The base class for Quantum network messages |
| CRemovePlayer | The client requests to remove a player from the simulation |
| CRemovePlayerFailed | The server reponds to RemovePlayer with this message if the player could not be removed |
| CRttUpdate | This message is sent frequently from the client to the server to synchronize the distributed systems |
| CSerializer | The Quantum online protocol serializer |
| CSimulationStart | The server sends the start signal |
| CSimulationStop | The simulation stopped message. Is not used yet |
| CStartRequest | The client request to start a online simulation session |
| CTickChecksum | This message contains the client game state checksum for a specific tick |
| CTickChecksumError | The message is sent from the server to the client when a checksum error is detected |
| CTickChecksumErrorFrameDump | The message is sent from the client to the server to distribute the game state to compare on other clients |
| ►NServer | |
| CDeterministicPluginClient | The client representation in the Quantum server plugin |
| CDeterministicPluginSession | The session object of the Quantum server plugin. Only one session is being created by one DeterministicServer |
| CDeterministicServer | The Quantum server class. Override virtual methods to extend its functionality |
| ►NSimulator | |
| ►NWebhooks | |
| CDeterministicSessionConfigJsonConverter | A custom JsonConverter for the DeterministicSessionConfig object. The class contains fields that need to be serialized which in only available in net5.0 |
| CReplayChunkRequest | The json webrequest is send if using ReplayStream.WebhookRequestType.Json. Binary web request holds all meta information in according headers |
| CBitStream | Writes information at the bit level to a byte array |
| CByteUtils | Utility class for working with bytes |
| CChecksumErrorFrameDump | A class that accumulates frame dumps from other clients during a checksum desync |
| CConfigParsingExtensions | Used by the server to parse the config information |
| CDeterministicChecksumResult | The data checksum is used to verify the integrity of the simulation |
| CDeterministicCommand | The base class for deterministic commands. Always override Serialize(BitStream) to add additional data |
| CDeterministicCommandPool | Create a deterministic command pool for a specific command type. Make sure to reset all command data when reusing the objects |
| CDeterministicCommandSerializer | The DeterministicCommandSerializer is used to serialize and de-serialize DeterministicCommands |
| CDeterministicFrame | The base class for the simulation frame. Also referred as rollback-able game state |
| CDeterministicFrameInputTemp | A struct that saves input data for a player duplicating internal input data that is not save to use because of recycling |
| CDeterministicFrameRingBuffer | The frame ring buffer is a utility collection class that stores a fixed number of latest frames in a ring buffer, usually in a certain time interval. A use-case for example are instant replays which allow to create a new simulation in the past time of the main simulation |
| CDeterministicInput | Obsolete type |
| CDeterministicPlatformInfo | Essential platform dependent information and implementations |
| CDeterministicPlayerMap | A utility class to collect a list of players and player slots. A client can maintain multiple players with individual player slots. The player always refers to a global player index that is the same on all clients. The player slot is a zero based index counting the number of players that one client controls. E.g. a client has two players: PlayerRef 5 and PlayerRef 2, the player slots are 0 and 1 |
| CDeterministicPlugin | Override the Quantum plugin class to create a custom server object |
| CDeterministicPluginFactory | The default Quantum plugin factory. Replace with custom implementation of IPluginFactory. Change the name accordingly in your Photon dashboard and in this file (Photon-Server\deploy\LoadBalancing\GameServer\bin\plugin.config) to run locally |
| CDeterministicProtocolVersionAttribute | The assembly attribute to specify the deterministic protocol version |
| CDeterministicSession | Represents a Quantum runtime match, holding the references to Game, its Frames (game state) and Simulator, and implements (together with Simulator) the predict/rollback logic, time control and input management. Single use, so whenever a Session is shutdown (or disconnected), it can't be reused anymore and a new one must be instantiated |
| CDeterministicSessionArgs | Represents the starting arguments for a deterministic constructor |
| CDeterministicSessionConfig | Parameterize internals of the Deterministic simulation and plugin (the Quantum server component) |
| CDeterministicStats | Deterministic simulation statistic |
| CDeterministicTickChecksum | An object that contains a tick and a checksum |
| CDeterministicTickChecksumError | A collection of checksums when an error was recognized |
| ►CDeterministicTickInput | The internal input structure for one player and one tick |
| CCorruptedException | The corrupted exception is thrown when error during the deserialization are detected |
| CPool | The input objects are pooled |
| CDeterministicTickInputDecoder | The decoder helps to deserialize the input from the server |
| CDeterministicTickInputEncodeHeader | Input header information |
| CDeterministicTickInputSet | The complete input set of all players for a single tick |
| ►CFP | A fixed-point number. 16 lower bits are used for the decimal part, 48 for the integral part |
| CComparer | Compares FPs |
| CEqualityComparer | Equality comparer for FPs |
| CRaw | Holds FP constants in raw (long) form |
| CFPBounds2 | Represents an 2D axis aligned bounding box (AABB) |
| CFPBounds3 | Represents an 3D axis aligned bounding box (AABB) |
| CFPCollision | A collection of collision helper functions |
| ►CFPHighPrecisionDivisor | Represents a high precision divisor for use with the Fixed Point math system |
| CRaw | Holds FPHighPrecisionDivisor constants in raw (long) form |
| CFPLut | The lookup table for the inverse cosine function. The table stores precalculated values of the inverse cosine function for specific angles. The values are in fixed-point format with a precision of 16 bits |
| CFPMath | A collection of common math functions |
| CFPMatrix2x2 | Represents 2x2 column major matrix, which can be used for 2D scaling and rotation. Each cell can be individually accessed as a field (M<row><column>) |
| CFPMatrix3x3 | Represents 3x3 column major matrix. Each cell can be individually accessed as a field (M<row><column>), with indexing indexing property[row, column] or with indexing property[index] |
| CFPMatrix4x4 | Represents 4x4 column major matrix. Each cell can be individually accessed as a field (M<row><column>), with indexing indexxing property[row, column] or with indexing property[index] |
| CFPQuaternion | A Quaternion representing an orientation |
| ►CFPVector2 | Represents a 2D Vector |
| CEqualityComparer | Represents an equality comparer for FPVector2 objects |
| ►CFPVector3 | Represents a 3D Vector |
| CEqualityComparer | Represents an equality comparer for FPVector3 objects |
| CIDeterministicCommandFactory | The command factor interface |
| CIDeterministicCommandPool | Command pool interface |
| CIDeterministicDeltaCompressedInput | The interface encapsulates managing the access to delta compressed input |
| CIDeterministicFrameSerializer | The interface of the serializer object used to serialize and deserialize components |
| CIDeterministicGame | The deterministic game interface is the main hub that holds information about the simulation on the Quantum.Deterministic level |
| CIDeterministicInputProvider | The interface encapsulates managing the Quantum input |
| CIDeterministicPlatformTaskRunner | The interface for the task runner used in the Quantum task system |
| CIDeterministicReplayProvider | An internal interface to encapsulate managing rpc and input |
| CIDeterministicRpcProvider | The interface encapsulates managing the Quantum RPCs |
| CIDeterministicStreamReplayInputProvider | The interface to implement streaming input for a Quantum replay session |
| CInputSetMask | The input mask is a utility struct to keep track of which players are included in a set of inputs. Max player count supported is 128. Internally the mask is split into two ulongs |
| ►CIntVector2 | Represents a two-dimensional vector with integer components |
| CEqualityComparer | Represents an equality comparer for IntVector2 objects |
| ►CIntVector3 | Represents a three-dimensional vector with integer components |
| CEqualityComparer | Represents an equality comparer for IntVector3 objects |
| ►CNative | Native is a collections of tools that interact with the platform's native code directly like memory allocation, copy operations, etc |
| CAllocator | Represents native memory allocations and is used in many places across the engine |
| CAllocatorVTable | Equal to the AllocatorVTableManaged but with marshaled function pointers |
| CAllocatorVTableManaged | A class that wraps memory allocation methods to be used in native code parts of the engine |
| CLIBCAllocator | The libc native allocator implementation |
| CLIBCUtility | The libc native memory utility implementation |
| CMSVCRTAllocator | The MSVCRT native allocator implementation |
| CMSVCRTUtility | The MSVCRT native memory utility implementation |
| CPInvokeAllocator | A specific allocator that tracks allocations in Debug mode |
| CUtility | Represents a collection of memory utility functions that interact with the platform's native code directly |
| CNullableFP | A serializable equivalent of Nullable<FP> |
| CNullableFPVector2 | A serializable equivalent of Nullable<FPVector2> |
| CNullableFPVector3 | A serializable equivalent of Nullable<FPVector3> |
| CNullableNonNegativeFP | A serializable equivalent of Nullable<FP> |
| CPlane | Represents a plane in three-dimensional space |
| CRNGSession | PCG32 random generator, 16 bytes in size. http://www.pcg-random.org |
| ►NQuantum | |
| ►NAllocator | |
| CFrameHeap | Managed frame heap type that wraps a unmanaged Heap instance |
| ►CHeap | The Quantum heap is a custom memory allocator that contains rollback-able memory allocations by Quantum user or internal systems. It implements the ITrackableFrameHeap interface for memory leak tracking |
| CConfig | The configuration of the frame heap |
| CStats | Statistics of the heap |
| CHeapAllocationTrackerExt | Extension methods for the IHeapAllocationTracker |
| CIFrameHeap | Custom heap interface for allocating memory on the frame |
| CIHeapAllocationTracker | Interface of the heap allocation tracker |
| CITrackableFrameHeap | Adds memory allocation tracking to the IFrameHeap |
| CSimpleHeapAllocTracker | An allocation tracker for the frame Heap. This implemention is used when HeapTrackingMode.DetectLeaks mode is selected |
| CTracedHeapAllocTracker | An allocation tracker for the frame Heap. This implementation is used when HeapTrackingMode.TraceAllocations mode is selected |
| ►NCollections | |
| CQCollectionsUtils | Helper class with utility methods used by QCollections |
| CQDictionary | A Quantum dictionary-like collection which uses the frame heap. This collection relies on Frame and on its API for allocating, deallocating and resolving |
| CQDictionaryIterator | An iterator for traversing the entries of a QDictionary<K, V>. This iterator allows for traversing the key-value pairs stored within the dictionary in a sequential manner |
| CQDictionaryPtr | Stores a Quantum.Ptr which points to the memory location of a QDictionary<K, V> inside the frame heap |
| CQEnumDictionary | A Quantum dictionary-like collection which uses the frame heap. Used in Quantum dictionaries which uses an Enum as the key type.This collection relies on Frame and on its API for allocating, deallocating and resolving |
| CQHashSet | A Quantum hashset-like collection which uses the frame heap. This collection relies on Frame and on its API for allocating, deallocating and resolving |
| CQHashSetIterator | An iterator for traversing the entries of a QHashSet<T>. This iterator allows for traversing the values stored within the hash set in a sequential manner |
| CQHashSetPtr | Stores a Quantum.Ptr which points to the memory location of a QHashSet<T> inside the frame heap |
| CQList | A Quantum list-like collection which uses the frame heap. This collection relies on Frame and on its API for allocating, deallocating and resolving |
| CQListPtr | Stores a Quantum.Ptr which points to the memory location of a QList<T> inside the frame heap |
| ►NCore | |
| CCompoundCommand | An auxiliary command that can be used to send multiple commands in one. Nested compound commands are accepted |
| CCullingSystem2D | During Predicted frames, culls all cullable entities with Transform2D that are positioned out of the prediction area |
| CCullingSystem3D | During Predicted frames, culls all cullable entities with Transform3D that are positioned out of the prediction area |
| ►CDebugCommand | The DebugCommand class allows to send debug commands to the simulation. It's used by the Quantum state inspector for example. The system is completely disabled in non-development builds or when defining QUANTUM_DEBUG_COMMAND_DISABLED |
| CPayload | The debug command payload |
| CDebugCommandType | Predefined debug commands |
| CEntityPrototypeSystem | The Quantum core system that creates map entities from the map prototype. Switching maps will destroy all entities and create new ones |
| ►CFrameBase | The Frame class is the container for all the transient and static game state data, including the API for entities, physics, assets and others |
| CCulling | The Culling class handles the scheduling of culling tasks |
| CEntitiesConfig | Global entities configuration |
| CFrameBaseUnsafe | Frame API to give access to C# unsafe pointers and advanced immediate operations |
| CStats | Represents the memory statistics for a frame in the Quantum.Core namespace |
| ►CFrameContext | The FrameContext is shared between individual transient FrameBase instances |
| CArgs | The FrameContext creating arguments |
| CICollisionCallbacks2D | Interface for receiving 2D collision callbacks |
| CICollisionCallbacks3D | Interface for receiving 3D collision callbacks |
| CIDerivedStruct | An interface representing a derived struct. Not meant to be used directly. Quantum's code generation supports structs inheritance and emits the interface implementation if needed |
| CNavigationSystem | The Quantum core navigation system |
| CPhysicsSystem2D | The Quantum core physics system |
| CPhysicsSystem3D | The Quantum 3D physics system |
| CPlayerConnectedSystem | The Quantum core player connected system. It will detect changes in the Photon.Deterministic.DeterministicFrame.GetPlayerInputFlags(PlayerRef) and call ISignalOnPlayerConnected and ISignalOnPlayerDisconnected respectively |
| CRingBuffer | Ring buffer collection implementation. Stores Capacity number of values and will overwrite the oldest value when full |
| CStreamUtils | Streaming utility methods |
| ►NDemo | |
| CQuantumSimpleConnectionGUI | A Unity script that demonstrates how to connect to a Quantum cloud and start a Quantum game session |
| ►NEditor | |
| ►CAssetDatabaseUtils | Utility methods for working with Unity's AssetDatabase |
| CAssetEnumerable | Enumerable of assets in the project that match the given search criteria |
| CAssetEnumerator | Enumerates assets in the project that match the given search criteria using HierarchyProperty API. Obtained with AssetDatabaseUtils.IterateAssets |
| CIQuantumAssetSourceFactory | A factory that creates IQuantumAssetSource instances for a given asset |
| CQuantumAssetSourceFactoryContext | A context object that is passed to IQuantumAssetSourceFactory instances to create an IQuantumAssetSource instance |
| CQuantumAssetSourceFactoryResource | A IQuantumAssetSourceFactory implementation that creates QuantumAssetSourceResource<TAsset> instances for assets in the Resources folder |
| CQuantumAssetSourceFactoryStatic | A IQuantumAssetSourceFactory implementation that creates QuantumAssetSourceStaticLazy<TAsset> |
| CQuantumCodeGenQtn | Quantum CodeGen for Qtn files. This type is placed in a standalone asmdef to make sure it can be compiled and run even in case of compile errors in other parts of the project |
| CQuantumCodeGenSettings | Settings for the Quantum code generation. Extend this class with a partial implementation to customize the settings |
| CQuantumDotnetBuildSettings | A configuration asset to generate and build the non-Unity Quantum simulation dll |
| CQuantumDotnetBuildSettingsInspector | Inspector code to manage the QuantumDotnetBuildSettings asset in the editor |
| CQuantumDotnetProjectSettings | A configuration asset that describes the search paths to create a non-Unity simulation project |
| CQuantumEditor | Base class for all Photon Common editors. Supports EditorButtonAttribute and ScriptHelpAttribute |
| CQuantumEditorColliderConverter | This tool can convert Unity colliders to Quantum colliders |
| CQuantumEditorFrameDifferWindow | The Quantum Frame Differ window shown in the Unity Editor. Readable and comparable frame dumps are sent by other clients and can be compared after a desync error |
| CQuantumEditorHubWidgetBase | Structured as such that a subclass has child elements to prevent Unity inspector recursion problems |
| CQuantumEditorMapGizmoStylePopup | Popup window for the map gizmo style |
| CQuantumEditorMenuCreateAssets | Create Quantum asset and script files using the context menu |
| CQuantumEditorMenuCreateScene | Utility methods to create and set up a Quantum Unity scene |
| CQuantumEditorMenuCustomPlugin | Methods to export Quantum assets and configs |
| CQuantumEditorMenuDllToggle | A static utility class that enabled Unity menu methods to toggle Quantum Debug and Release dlls by extracting a zip archive and overwriting the libraries. In earlier versions this was handed by the QUANTUM_DEBUG define and multiple version of dlls but the Quantum.Engine.dll has internal MonoBehaviours that lose the script guids this way |
| CQuantumEditorMenuLookUpTables | Quantum Look up table tools |
| CQuantumEditorMenuProfilers | Utility methods to create and set up a Quantum Unity scene |
| CQuantumEditorSessionShutdown | An Unity Editor hook to shutdown all Quantum sessions when the editor play mode is stopped |
| ►CQuantumEditorShortcutsWindow | A utility window to quickly access Quantum global configs |
| CGridScope | A grid scope for the Quantum global config window |
| CQuantumEditorSkin | An editor scriptable object that stores UI skins and different GUIStyle Unity inspectors and custom windows |
| CQuantumEditorToolbarUtilities | An editor script that places a drop down selection to quickly load Unity scenes, which are listed in the BuildSettings. To disabled the toolbar toggle QuantumEditorSettings.UseQuantumToolbarUtilities |
| CQuantumEditorUserScriptGeneration | Utility methods to create initial user files required for the Quantum SDK. These files are never overwritten by SDK updates. Files include asmref files, readme files or partial classes. Files are identified by their Unity script GUIDs |
| CQuantumGlobalScriptableObjectUtils | Utility methods for working with QuantumGlobalScriptableObject |
| CQuantumInstantReplayDemoEditor | A custom editor to for the instant replay demo. Displays start and stop buttons |
| CQuantumMenuConfigEditor | Custom inspector for QuantumMenuSceneInfo |
| CQuantumProfilingServer | A dummy implementation of the Quantum profiling server |
| CQuantumQtnAsset | A text asset that stores Quantum DSL (domain specific language) code. Quantum requires components and other runtime game state data types to be declared within. Upon any of these assets changing, QuantumCodeGenQtn.Run() is called. To disable this behavior, define |
| CQuantumStateInspector | An editor class that renders the Quantum state inspector used to reveal internal state of Quantum entities during run-time. Open the window by using Tools > Quantum > Window > State Inspectors |
| CQuantumUnityDBInspector | An editor class that renders a windows displaying assets from the Quantum DB. Open the windows by using Tools > Quantum > Window > Quantum Unity DB |
| CQuantumUnityDBUtilities | QuantumUnityDB Editor utilities |
| CSerializableEnterRoomArgs | This class wraps the PhotonRealtime EnterRoomArgs class to make problematic members (Hashtable, TypedLobby restrictions) and its hierarchy XML serializable. |
| ►NJson | |
| CByteArrayConverter | Converts byte arrays to and from JSON in a way compatible with the Unity's built-in JSON utility |
| CFixedSizeBufferConverter | Converts fixed-size buffers to and from JSON in a way compatible with the Unity's built-in JSON utility |
| CUnityContractResolver | Custom contract resolver for Unity objects. The main purpose is to support Unity's SerializeReference attribute |
| CUnityJsonUtilityConvert | Utility methods to convert JSON data serialized by Unity's built-in JSON utility to .NET objects with Newtonsoft.Json |
| ►NPhysics2D | |
| CCollisionResultInfo2D | A structure for containing all the result information from the collision between two shapes |
| CDistanceJoint | A Joint that connects a Physics Body to an anchor and attempts to keep them a certain distance apart. The connected anchor can be a world-space position or another entity with at least a transform component |
| CHingeJoint | A Joint that attaches a Physics Body to an anchor around which it can rotate. The connected anchor can be a world-space position or another entity with at least a transform component. The rotation can happen freely or, optionally, with limiting angles and/or a motor torque |
| CHit | Information returned from a valid hit of a physics query |
| CHitCollection | Collection of hits returned from a physics query |
| CJoint | Defines a connection between a 2D Physics Body and an anchor, according to velocity and/or position constraints. The connected anchor can be a world-space position or another entity with at least a transform component |
| ►CPhysicsEngine2D | 2D Physics API |
| ►CApi | 2D Physics API |
| CThreadSafeApi | Struct to provide thread-safe access to the physics functions |
| CSpringJoint | A Joint that attaches a Physics Body to an anchor as if connected by a spring, trying to keep them a certain distance apart. The connected anchor can be a world-space position or another entity with at least a transform component |
| ►NPhysics3D | |
| CDistanceJoint3D | A Joint3D that connects a Physics Body to an anchor and attempts to keep them a certain distance apart. The connected anchor can be a world-space position or another entity with at least a transform component |
| CHingeJoint3D | A Joint3D that attaches a Physics Body to an anchor around which it can rotate. The connected anchor can be a world-space position or another entity with at least a transform component. The rotation can happen freely or, optionally, with limiting angles and/or a motor torque |
| CHit3D | Information returned from a valid hit of a physics query |
| CHitCollection3D | Collection of hit information returned from a physics query |
| CJoint3D | Defines a connection between a 3D Physics Body and an anchor, according to velocity and/or position constraints. The connected anchor can be a world-space position or another entity with at least a transform component |
| ►CPhysicsEngine3D | 3D Physics API |
| ►CApi | 3D Physics API |
| CThreadSafeApi | Struct to provide thread-safe access to the physics functions |
| CSpringJoint3D | A Joint3D that attaches a Physics Body to an anchor as if connected by a spring, trying to keep them a certain distance apart. The connected anchor can be a world-space position or another entity with at least a transform component |
| ►NProfiling | |
| ►CProfiler | Represents a profiler that can be used for performance profiling |
| CProfilerScope | Represents a disposable profiler scope that automatically starts and ends a profiling section |
| CProfilerContext | Represents a profiler context that manages profiling data |
| CProfilerContextData | Represents the data collected by the profiler for all the threads for a single frame |
| CProfilerData | Data collected by the profiler |
| CQuantumGraphPlayerLoopUtility | A system to add profiler callbacks into the Unity player loop |
| CQuantumGraphPool | A pool for QuantumGraphTimer objects |
| CQuantumGraphProfiler | The base class for all Quantum graph profilers |
| CQuantumGraphProfilerDeltaTime | A graph profiler that records the delta time |
| CQuantumGraphProfilerFrameTime | A Quantum graph profiler that records the frame time |
| CQuantumGraphProfilerGC | A Quantum graph profiler that records the garbage collection time |
| CQuantumGraphProfilerMarkers | A Quantum graph profiler that records custom markers |
| CQuantumGraphProfilerMarkerSeries | A graph profiler that records a series of markers |
| CQuantumGraphProfilerNetworkActivity | A Quantum graph profiler that shows the time delta between the last received packet |
| CQuantumGraphProfilerPing | A Quantum graph profiler that shows the RTT to the server |
| CQuantumGraphProfilerPredictedFrames | A Quantum graph profiler that shows how far the simulation is in predicting |
| CQuantumGraphProfilerRenderTime | A Quantum graph profiler that shows the render time |
| CQuantumGraphProfilers | The main management class in the Quantum graph profilers |
| CQuantumGraphProfilerSimulationTime | A Quantum graph profiler that shows the simulation time |
| CQuantumGraphProfilersUtility | A utility class for Quantum graph profilers |
| CQuantumGraphProfilerUserScripts | A Quantum graph profiler that shows the time spent in Unity scripts |
| CQuantumGraphProfilerValueSeries | Records a series of values for a graph profiler |
| CQuantumGraphProfilerVerifiedFrames | A Quantum graph profiler that shows how many verified frames have been simulated during the last update |
| CQuantumGraphProfilingStatistics | A Unity script that renders additional statistics to the graph UI |
| CQuantumGraphProfilingTools | A Unity script that renders additional profiling tools to the graph UI |
| CQuantumGraphSeries | A graph series is the base class to render graphs in Unity |
| CQuantumGraphSeriesMarker | The rendering of a marker series |
| CQuantumGraphSeriesValue | The series value graph is used format, average values add graphical features to the graph rendering |
| CQuantumGraphTimer | The Quantum graph timer to measure time with a stopwatch |
| CSample | Represents a sample in the profiler |
| ►NPrototypes | |
| CCharacterController2DPrototype | Prototype of the CharacterController2D Quantum component |
| CCharacterController3DPrototype | Prototype of the CharacterController3D Quantum component |
| CDistanceJoint3DConfig | Defines a prototype of a Joint3D struct of type JointType3D.DistanceJoint |
| CDistanceJointConfig | Defines a prototype of a Joint struct of type JointType.DistanceJoint |
| CFrameTimerPrototype | Prototype to create a FrameTimer component |
| CHingeJoint3DConfig | Defines a prototype of a Joint3D struct of type JointType3D.HingeJoint |
| CHingeJointConfig | Defines a prototype of a Joint struct of type JointType.HingeJoint |
| CJoint2DConfig | Defines a prototype of a Joint struct of any type |
| CJoint3DConfig | Defines a prototype of a Joint3D struct of any type |
| CNavMeshAvoidanceAgentPrototype | Prototype of the NavMeshAvoidanceAgent Quantum component |
| CNavMeshAvoidanceObstaclePrototype | Prototype of the NavMeshAvoidanceObstacle Quantum component |
| CNavMeshPathfinderPrototype | Prototype of the NavMeshPathfinder Quantum component |
| CNavMeshSteeringAgentPrototype | Prototype of the NavMeshSteeringAgent Quantum component |
| CPhysicsBody2DPrototype | Prototype of the PhysicsBody2D Quantum component |
| CPhysicsBody3DPrototype | Prototype of the PhysicsBody3D Quantum component |
| CPhysicsCallbacks2DPrototype | Prototype of the PhysicsCallbacks2D Quantum component |
| CPhysicsCallbacks3DPrototype | Prototype of the PhysicsCallbacks3D Quantum component |
| CPhysicsCollider2DPrototype | Prototype of the PhysicsCollider2D Quantum component |
| CPhysicsCollider3DPrototype | Prototype of the PhysicsCollider3D Quantum component |
| CPhysicsJoints2DPrototype | Prototype of the PhysicsJoints2D Quantum component |
| CPhysicsJoints3DPrototype | Prototype of the PhysicsJoints3D Quantum component |
| CSpringJoint3DConfig | Defines a prototype of a Joint3D struct of type JointType3D.SpringJoint |
| CSpringJointConfig | Defines a prototype of a Joint struct of type JointType.SpringJoint |
| CTransform2DPrototype | Prototype of the Transform2D Quantum component |
| CTransform2DVerticalPrototype | Prototype of the Transform2DVertical Quantum component |
| CTransform3DPrototype | Prototype of the Transform3D Quantum component |
| CViewPrototype | Prototype of the View Quantum component |
| ►NTask | |
| CSystemArrayComponent | A multi-threaded system to parallelize updating components |
| CSystemArrayFilter | A multi-threaded system to parallelize updating components |
| CSystemThreadedComponent | A multi-threaded system to parallelize updating components |
| CSystemThreadedFilter | |
| CArrayLengthAttribute | Editor attribute for selecting the minimum and maximum length constraints for an array field |
| CArrayUtils | A collection of utility methods for working with arrays |
| CAssemblyNameAttribute | Specifies that the attributed field represents the name of an assembly |
| CAssert | Provides methods for asserting conditions. Throws an AssertException when a condition is not met. Methods are only invoked in DEBUG builds unless otherwise specified |
| CAssertException | An exception that is thrown when an assertion fails |
| CAssetGuid | Represents a unique identifier for an asset |
| CAssetObject | A base class for all Quantum asset objects |
| CAssetObjectIdentifier | A struct that identifies an asset object by either its GUID and (optionally) path |
| CAssetRef | An indirect reference to an AssetObject |
| CBinaryData | An asset containing raw binary data. Use CreateByteStream to access contents safely and auto-decompress, if compressed |
| CBinaryDataAttribute | Specifies that the field represents binary data |
| CBitSet1024 | A bitmask with 1024 bits |
| CBitSetAttribute | Represents an attribute that specifies the number of bits in a bit set |
| CBitSetRef | A variable sized bitmask |
| CBitStreamExtensionsCore | Bit steam extensions methods to serialize Quantum specific concrete types |
| CBitStreamReplayInputProvider | This implementation of IDeterministicStreamReplayInputProvider is used to provide delta compressed input for a Quantum simulation replay from a BitStream |
| CButton | The Quantum button used for player input. Instead of using bools or similar data types to represent key presses, the Button type is used inside the Input DSL definition. This is because it only uses one bit per instance, so it is favorable to use where possible. Although they only use one bit over the network, locally they will contain a bit more game state. This is because the single bit is only representative of whether or not the button was pressed during the current frame, the rest of the information is computed locally |
| CByteSerializerHashMapper | Maps value hashes to an indexed collection of previous values. Can be used in combination with a ByteStream to avoid serializing the same value multiple times |
| CByteStream | The byte stream is a class to serialize and deserialize byte-wise data. It's mostly used by Quantum asset serialization and deserialization. The data is stored inside a byte array internally |
| CByteStreamExtension | Byte stream extension methods |
| CCallbackBase | The base class for callbacks adds an id to the callback |
| CCallbackChecksumComputed | Callback called when a checksum has been computed |
| CCallbackChecksumError | Callback called on a checksum error |
| CCallbackChecksumErrorFrameDump | Callback called a frame dump is received due to a checksum error |
| CCallbackDispatcher | A subscribe and publish pattern for Quantum callbacks. A Quantum callback is a invocation from inside the simulation during certain situations |
| CCallbackEventCanceled | Callback called when an event raised in a predicted frame was canceled in a verified frame due to a roll-back / missed prediction. Synchronised events are only raised on verified frames and thus will never be canceled; this is useful to graciously discard non-sync'ed events in the view |
| CCallbackEventConfirmed | Callback called when an event was confirmed by a verified frame |
| CCallbackGameDestroyed | Callback called when the game was destroyed |
| CCallbackGameInit | Callback called when the game is about to start |
| CCallbackGameResynced | Callback called when the game has been re-synchronized from a snapshot and is about to start. Will be followed by the CallbackGameStarted callback."/> |
| CCallbackGameStarted | Is called during QuantumGame.OnGameStart or QuantumGame.OnGameResync when the game is started after systems are initialized and the snapshot has arrived for late-joining clients |
| CCallbackInputConfirmed | Callback when input was confirmed |
| CCallbackLocalPlayerAddConfirmed | Callback when a local player was successfully added to the game |
| CCallbackLocalPlayerAddFailed | Callback when a adding a local player failed |
| CCallbackLocalPlayerRemoveConfirmed | Callback when a local player was successfully removed from the game |
| CCallbackLocalPlayerRemoveFailed | Callback when removing a local player failed |
| CCallbackPluginDisconnect | Callback called when the local client is disconnected by the plugin |
| CCallbackPollInput | Callback called when the simulation queries local input |
| CCallbackSimulateFinished | Callback called when frame simulation has completed |
| CCallbackTaskProfilerReportGenerated | Callback when ProfilerContextData has been generated |
| CCallbackUnitySceneLoadBegin | Callback sent when a Unity scene load begins. To enable this feature SimulationConfig.AutoLoadSceneFromMap must be toggled on |
| CCallbackUnitySceneLoadDone | Callback sent when a Unity scene load is done |
| CCallbackUnitySceneUnloadBegin | Callback sent when a Unity scene unload begins |
| CCallbackUnitySceneUnloadDone | Callback sent when a Unity scene unload is done |
| CCallbackUpdateView | Callback guaranteed to be called every rendered frame |
| CCharacterController2D | A component for kinematic character controller prototyping that uses a circle as a shape. You can quickly add this to an entity and set a CharacterController2DConfig, then call the CharacterController2D.Move(FrameBase, EntityRef, FPVector2, IKCCCallbacks2D, int?, bool?, FP?) method in a system update |
| CCharacterController2DConfig | The configuration values of the CharacterController2D. Use this to setup the kcc shape size and tune its movement and collision detection |
| CCharacterController2DMovement | Result of a 2D KCC raw movement query |
| CCharacterController3D | A component for kinematic character controller prototyping that uses a sphere as a shape. You can quickly add this to an entity and set a CharacterController3DConfig, then call the CharacterController3D.Move(FrameBase, EntityRef, FPVector3, IKCCCallbacks3D, int?, bool?, FP?) method in a system update |
| CCharacterController3DConfig | The configuration values of the CharacterController3D. Use this to setup the kcc shape size and tune its movement and collision detection |
| CCharacterController3DMovement | Result of a 3D KCC raw movement query |
| CChecksumErrorFrameDumpContext | Gathers additional meta data during the Quantum game callback IDeterministicGame.GetExtraErrorFrameDumpData in response to a checksum error |
| ►CChecksumFile | A serializable object that contains recorded checksums for a Quantum session |
| CChecksumEntry | Represents one recorded checksum |
| CChecksumFileHelper | Helper methods to convert between ulong and long |
| ►CCollisionInfo2D | Info about a collision between two 2D physics colliders |
| CContactPointIterator2D | A helper for safety interaction through the contact point buffer |
| ►CCollisionInfo3D | Info about a collision between two 3D physics colliders |
| CContactPointIterator3D | An iterator over multiple triangles collisions with a given mesh |
| CTriangleCollisionInfo | Info about the collision with a specific triangle of a mesh |
| CTriangleCollisionIterator | Data regarding a mesh collision, including all the individual triangles |
| ►CColorRGBA | Quantum representation of a color with 4 channels (R, G, B, A) each represented by a byte |
| CEqualityComparer | The equality comparer for ColorRGBA instances |
| CComponentCallbacks | Component callbacks |
| CComponentFilter | Filter entities by component types |
| CComponentFilterStruct | Component filter |
| CComponentFilterStructMeta | Component filter that is initialized from a filter class having component fields |
| CComponentPrototypeRef | Represents a generalized reference to a component prototype. The prototype can either come from an entity prototype asset or from a map asset. Type is stored as a ComponentTypeRef |
| CComponentTypeId | Runtime information for component types, containing their ID, size, flags and callbacks |
| CComponentTypeSetSelector | Represents a set of component types. Use ComponentTypeRef array insteadd |
| CConsoleLogger | Not used anymore |
| CConsoleLogStream | A log stream that writes log messages to the console with a specified color |
| CContextMenuAttribute | A replacement for UnityEngine.ContextMenuAttribute |
| CCreateAssetMenuAttribute | A replacement for UnityEngine.CreateAssetMenuAttribute |
| CDebugDraw | This class will draw shapes issued by the simulation (e.g. Draw.Sphere(Photon.Deterministic.FPVector3, Photon.Deterministic.FP, ColorRGBA?, bool)) The shape drawing is based on the DEBUG define which is enabled in UnityEditor and development builds. Can be globally toggled of by using IsEnabled |
| CDebugMesh | Access to Quantum debug mesh resources. Obsolete: has been replaced by QuantumMeshCollection.Global |
| CDecoratingPropertyAttribute | A base class for property attributes that decorate other property attributes |
| CDeterministicCommandSetup | A partial static class to extend by implementing the partial method AddCommandFactoriesUser. It's used to create the Quantum command factories when initializing the simulation, either DeterministicCommand or DeterministicCommandPool<T> object. Only commands added here can be invoked by the simulation |
| CDeterministicSystemSetup | Responsible for instantiating Quantum systems on simulation start. User systems can be added by adding a SystemsConfig to the RuntimeConfig. Or adding them in the user callback AddSystemsUser |
| CDictionaryAttribute | Represents an attribute that can be applied to a field to indicate that it is a dictionary property |
| CDictionaryEntryPrototype | Obsolete class |
| ►CDispatcherBase | Base class for dispatchers. Dispatchers are used to publish and subscribe to events represented by IDispatchable objects |
| CHandlerDisposable | A helper class that allows to create a subscription that is active until the caller disposes the result |
| CDispatcherHandlerFlags | Built-in flags for DispatcherBase.Subscribe<TDispatchable>(object, DispatchableHandler<TDispatchable>, bool, uint, DispatchableFilter) |
| CDisplayAsEnumAttribute | Casts an enum or int value in the inspector to specific enum type for rendering of its popup list. Supplying a method name rather than a type allows a property with the type Type to be used to dynamically get the enum type |
| CDisplayNameAttribute | Specifies the display name for a field |
| CDoIfAttributeBase | Editor attribute for selective editor rendering. Condition member can be a property, field or method (with a return value) |
| CDotNetRunnerFactory | Platform dependent information and factory methods for the SessionRunner. This implementation of the IRunnerFactory is not unused in Unity but in standalone Quantum applications and on the Quantum server plugin |
| CDotNetSessionContext | This class implements the IDeterministicSessionContext interface inside the simulation project. It's used on the custom server to access Quantum simulation code like the resource manager and command serialization. A static resource manager is created during Init() that is shared between multiple server simulation instances |
| CDotNetSessionRunner | This class implements the IDeterministicSessionRunner interface and contains code to glue together the Quantum server and Quantum session runner. This was formerly part of the Quantum Server SDK. The class will also work without running the server simulation only as wrapper for access to custom simulation code as resource manager and command serialization for example |
| CDotNetTaskRunner | The implementation of IDeterministicPlatformTaskRunner for .Net frameworks. Not used when running the simulation in Unity |
| ►CDraw | Issues a debug shape to be drawn in Unity. The shape drawing is based on the DEBUG define which is enabled in UnityEditor and development builds. Can be globally toggled of by using DebugDraw.IsEnabled in Unity. Different implementation can be attached using Init(Action<Draw.DebugRay>, Action<Draw.DebugLine>, Action<Draw.DebugCircle>, Action<Draw.DebugSphere>, Action<Draw.DebugRectangle>, Action<Draw.DebugBox>, Action<Draw.DebugCapsule>, Action) |
| CDebugBox | Stores information to draw the debug shape box |
| CDebugCapsule | Stores information to draw the debug shape capsule |
| CDebugCircle | Stores information to draw the debug shape circle |
| CDebugLine | Stores information to draw the debug shape line |
| CDebugRay | Stores information to draw the debug shape ray |
| CDebugRectangle | Stores information to draw the debug shape rectangle |
| CDebugSphere | Stores information to draw the debug shape sphere |
| CDrawerPropertyAttribute | A base class for property attributes that are used to draw properties in the inspector |
| CDrawIfAttribute | Editor attribute for selectively drawing/hiding fields. Condition member can be a property, field or method (with a return value) |
| CDrawInlineAttribute | Specifies that a field should be drawn inline in the inspector |
| CDynamicAssetDB | A DynamicAssetDB is a database of assets that can be added and removed at runtime. For late joiners, contents are serialized and deserialized using an IAssetSerializer |
| CDynamicCollectionAttribute | Marks a collection field as source for a Quantum heap-based collection. Automatically applied by CodeGen |
| CDynamicMap | Used to dynamically edit and manage mesh colliders and their triangles at runtime. This is particularly useful in games with procedurally generated content or user-generated levels, where the environment can change dynamically |
| CEditMeshScope | Scope for editing triangles of a mesh collider |
| CEditorButtonAttribute | Specifies that a method should be displayed as a button in the Unity editor |
| CEditorDefines | Quantum editor defines |
| CEditorRectUtils | Unity custom editor GUI utility functions |
| CEntityComponentConfigAttribute | Obsolete attribute, use [CodeGen] instead |
| CEntityComponentPair | An entity-component pair. Used when iterating over components. Since this type contains a copy of the component, it is not suitable for writing back to the component |
| CEntityComponentPointerPair | An entity-component pointer pair. Used when iterating over components |
| CEntityPrototype | An asset that represents a prototype for an entity. Prototypes are a convenient way to define a set of components that can be instantiated at runtime using FrameBase.Create(Quantum.AssetRef<Quantum.EntityPrototype>) or FrameBase.Create(Quantum.EntityPrototype) methods |
| CEntityPrototypeRef | Represents a generalized reference to an entity prototype - either EntityPrototype asset or an entity from Map |
| CEntityRef | Quantum entity reference identifies a unique Entity |
| ►CEnumEqualityComparer | Enum utility methods |
| CTag | An empty struct to mark the type as a tag |
| CErrorIfAttribute | Editor attribute for adding notices to fields if the condition member evaluates as true. Condition member can be a property, field or method (with a return value) |
| CEventBase | The base class for Quantum events. Events are a fire-and-forget mechanism to transfer information from the simulation to the view |
| CEventDispatcher | Publish, subscribe pattern for Quantum events: EventBase. Quantum events are used to communicate view relevant game updates from the simulation to the view |
| CEventGameResult | Does not have to implement checksum, because it's a hard-coded synced event |
| CEventList | Internally used class |
| CExitInfo2D | Info about two entities that were colliding in the 2D Physics |
| CExitInfo3D | Info about two entities that were colliding in the 3D Physics |
| CExpandableEnumAttribute | Editor attribute that shows an enum as an expandable list of options in the inspector |
| CFieldEditorButtonAttribute | Editor attribute to add a button that invokes a custom method in the inspector |
| CFieldsMask | Base class for FieldsMask<T> |
| CFixedArray | Provides utility methods for working with Quantum fixed-size arrays |
| CFloatMinMax | A struct that holds min and max float values and comes with a few inspector tools |
| CFormerlySerializedAsAttribute | A replacement for UnityEngine.Serialization.FormerlySerializedAsAttribute |
| ►CFPAnimationCurve | A deterministic discretized animation curve. Values between keyframes are interpolated linearly |
| CKeyframe | Only used to recreate the curve in the Unity Editor |
| CFPMathUtils | Unity specific FixedPoint math utilities. All conversions between Unity float into Quantum FP (e.g. Vector2 to FPVector2) are considered non-deterministic and should never be used in the Quantum simulation directly |
| ►CFrame | The user implementation of FrameBase that resides in the project quantum_state and has access to all user relevant classes |
| CFrameSignals | The Quantum signal API consist of core and user-defined code-generated signals |
| CFrameChecksumerBitStream | Represents a bit stream used for frame checksum calculation. Implements the IBitStream interface |
| CFrameContextUser | Use this class to extend the Core.FrameContext class |
| CFrameThreadSafeExtensions | Extension methods for the FrameThreadSafe class |
| CFrameTimer | Built in timer used for timing game logic |
| CGameObjectUtils | Unity game object utility methods for Quantum |
| CGameResult | The game result class can be extended by a partial class. It is used with the EventGameResult to report the game result to the server. See the online documentation for more information |
| CGizmoIconColorAttribute | Defines the color of a gizmo header in the overlay |
| CGizmoUtils | Utility class for drawing gizmos |
| CGlobalsCore | Internally used class |
| CHashCodeUtils | Hashcode generation utilities |
| CHeaderAttribute | A replacement for UnityEngine.HeaderAttribute |
| CHideArrayElementLabelAttribute | Attribute used to hide the label of an array element in the inspector |
| CHideInInspectorAttribute | A replacement for UnityEngine.HideInInspector |
| CIAssetSerializer | Represents a serializer that handles assets and various configuration objects |
| CIAssetSerializerExtensions | An extension class for IAssetSerializer |
| CICallbackDispatcher | A callback dispatcher interface. Implementations of this interface are responsible for dispatching callbacks to the runtime |
| CICallbackUnityScene | An interface for callbacks that are related to Unity scenes |
| CIComponent | The interface to identify Quantum components |
| CIComponentSingleton | The interface to identify Quantum singleton components |
| CIDispatchable | The interface for the dispatchable callbacks or events |
| CIEntityPrototypeMaterializedListener | If implemented by ComponentPrototype, OnEntityPrototypeMaterialized will be invoked after the entire prototype has been materialized, but before Quantum.ISignalOnEntityPrototypeMaterialized. This is useful when a component needs some extra initialization after all the components have been materialized |
| CIEventDispatcher | An event dispatcher interface. Implementations of this interface are responsible for dispatching events to the runtime |
| CIKCCCallbacks2D | The interface receives the interaction callbacks from the character controller system |
| CIKCCCallbacks3D | The interface receives the interaction callbacks from the character controller system |
| CILogger | Represents a logger |
| CILogSource | An interface for log sources. Implement this interface to be able to pass a custom context to Log methods |
| CInactiveTaskRunner | An implementation of IDeterministicPlatformTaskRunner that forces the Quantum task system to run synchronously (single-threaded) |
| CINavigationCallbacks | Basic callbacks from the navigation system to Quantum systems |
| CInlineHelpAttribute | If applied to a field, checks if there is a help text for the field or the field's type and shows it in the inspector |
| CInputProvider | The input provider is used to push recorded inputs into the simulation. This class uses the full input history instead of delta compressed input stream which uses a large memory footprint |
| CInputProviderExtensions | Input provider extension methods |
| CInstantReplaySettings | Settings required to record frame snapshots for instant replays |
| CIProgressBar | A progress bar that reports back during navmesh baking |
| CIPrototype | A prototype interface. Indicates that the implementing type is a prototype of some kind |
| CIQString | QString interface for UTF-16 strings |
| CIQStringUtf8 | QString interface for UTF-8 strings |
| CIQuantumEntityViewPool | Interface to create custom implementation of the entity view pool that can be assigned to the QuantumEntityViewUpdater.Pool |
| CIQuantumUnityDispatcher | An interface marking a dispatcher as being a Quantum Unity dispatcher |
| CIQuantumUnityDispatcherExtensions | Set of extension methods for IQuantumUnityDispatcher |
| CIQuantumViewComponent | The interface that the QuantumEntityViewUpdater uses to control the view components (QuantumViewComponent<T>) |
| CIQuantumViewContext | Use this interface to create view context classes that can be used inside concrete QuantumEntityViewComponent<T> |
| CIResourceManager | Represents an asset manager that can load, unload, and dispose AssetObject |
| CIResourceManagerExtensions | Extension methods for IResourceManager |
| CIRunnerFactory | The interface for the runner factory. It creates platform specific objects to run the Quantum simulation |
| CISignal | Represents a signal. Not meant to be implemented directly |
| CISignalOnCollision2D | Interface for receiving callbacks once per frame while two non-trigger 2D colliders are touching |
| CISignalOnCollision3D | Interface for receiving callbacks once per frame while two non-trigger 3D colliders are touching |
| CISignalOnCollisionEnter2D | Interface for receiving callbacks once two non-trigger 2D colliders start touching |
| CISignalOnCollisionEnter3D | Interface for receiving callbacks once two non-trigger 3D colliders start touching |
| CISignalOnCollisionExit2D | Interface for receiving callbacks once two non-trigger 2D colliders stop touching |
| CISignalOnCollisionExit3D | Interface for receiving callbacks once two non-trigger 3D colliders stop touching |
| CISignalOnComponentAdded | |
| CISignalOnComponentRemoved | |
| CISignalOnEntityPrototypeMaterialized | |
| CISignalOnMapChanged | |
| CISignalOnNavMeshMoveAgent | |
| CISignalOnNavMeshSearchFailed | |
| CISignalOnNavMeshWaypointReached | |
| CISignalOnPlayerAdded | |
| CISignalOnPlayerConnected | |
| CISignalOnPlayerDataSet | Obsolete: use ISignalOnPlayerAdded |
| CISignalOnPlayerDisconnected | |
| CISignalOnPlayerRemoved | /> |
| CISignalOnTrigger2D | Interface for receiving callbacks once per frame while a non-trigger and a trigger 2D colliders are touching |
| CISignalOnTrigger3D | Interface for receiving callbacks once per frame while a non-trigger and a trigger 3D colliders are touching |
| CISignalOnTriggerEnter2D | Interface for receiving callbacks once a non-trigger and a trigger 2D colliders start touching |
| CISignalOnTriggerEnter3D | Interface for receiving callbacks once a non-trigger and a trigger 3D colliders start touching |
| CISignalOnTriggerExit2D | Interface for receiving callbacks once a non-trigger and a trigger 2D colliders stop touching |
| CISignalOnTriggerExit3D | Interface for receiving callbacks once a non-trigger and a trigger 3D colliders stop touching |
| CJointGizmoEntry | Individual entry for specifically the joint section of the gizmo overlay |
| CJsonUtilityExtensions | Extends capabilities of JsonUtility by adding type annotations to the serialized JSON, Unity object reference handling and integer enquotement |
| CLayerAttribute | Specifies that an int field should be drawn as a layer field in the inspector |
| CLayerInfo | Physics layer information |
| CLayerMask | The Quantum physics layer mask used with LayerValue |
| CLayerMatrixAttribute | Specifies that the integer array field should be drawn as a layer matrix in the inspector |
| CLayerValue | The Quantum physics layer value used with LayerMask |
| CLocalReferenceAttribute | Marks a field as a reference to a local object. In Unity, a local object is an object from the same scene or prefab. Automatically applied by CodeGen |
| CLog | Quantum's logging system |
| CLogContext | Additional info about the log context |
| CLogLevelExtensions | Extensions for LogLevel |
| CLogSettings | Settings for the logging system |
| CLogStream | Interface for logging streams |
| CMailboxSet8 | A utility class to optimize periodic checks by saving a iteration value for each index of the initial capacity |
| CMap | The Quantum map is a Quantum asset that contains information about the level and is used by the deterministic simulation to drive gameplay. Only one map can be loaded at a time |
| CMapDataBakerCallback | Derive from the class to receive callbacks during Quantum map baking. Add the QuantumMapBakeAssemblyAttribute assembly attribute when the implementation is located in different assemblies |
| CMapDataBakerCallbackAttribute | Add this attribute to implementations of MapDataBakerCallback to control the order in which the callbacks are finally executed. Works across different assemblies |
| CMapEntityId | Represents a Quantum entity that is part of a map |
| CMapEntityLink | Map entity link can be used inside a component to reference an entity from the map |
| CMapStaticCollider2D | The data structure to hold 2D static colliders for a Quantum map. Static colliders are baked into the map and are used for efficient collision detection |
| CMapStaticCollider2DPolygonData | Stores 2D polygon collider data used on static collider MapStaticCollider2D |
| CMapStaticCollider3D | The data structure to hold 3D static colliders for a Quantum map. Static colliders are baked into the map and are used for efficient collision detection |
| CMask256 | Mask256 is a 256-bit mask that can be used to store 256 boolean values |
| CMaxStringByteCountAttribute | Specifies that the string field should be drawn as a text field with a maximum byte count for given encoding |
| ►CMemoryLayoutVerifier | Verifies the memory layout of types and detects any potential issues |
| CDefaultPlatform | The default platform implementation |
| CIPlatform | Represents a platform that can resolve the memory layout of types and detect any potential issues |
| CMeshUnmanagedTrianglesRef | A lightweight reference to a mesh in unmanaged memory |
| CMinMaxSliderAttribute | An attribute to display a slider in the Unity inspector between a min and max value |
| CMovedFromAttribute | A replacement for UnityEngine.Scripting.APIUpdating.MovedFromAttribute |
| CMultiTypeReferenceAttribute | Adds one object picker per type to the inspector |
| ►CNavigation | Navigation API |
| CConfig | Global navmesh configurations which are part of the SimulationConfig |
| CConstants | Global navigation constants |
| CFindPathResult | The result object for FindPath requests |
| CIPathFinderData | An interface to access a few selected internal pathfinding data |
| CPathFinder | Navmesh TA* pathfinder class |
| CPathVertex | The data structure for the internal path waypoints |
| CThreadLocal | An internal class that stored multi-threading related navigation context |
| CNavMesh | The asset object that contains a Quantum navigation mesh. The object loads an additional data file during the Loaded. This is because of size limitations when loading the data with Unity serialization |
| CNavMeshAgentConfig | The configuration file for navmesh agent components |
| CNavMeshAgentSteeringData | Navmesh agent steering data passed into callbacks |
| CNavMeshAvoidanceAgent | A component that will make the agent avoid other agents while calculating the navigation steering. Requires NavMeshSteeringAgent and NavMeshPathfinder |
| CNavMeshAvoidanceObstacle | A component that represents a circle-shaped obstacle for navmesh agents to avoid. This is not altering the navmesh itself, but it is dynamic obstacle to be avoided by other agents steering |
| CNavMeshBakeData | he MapNavMesh.BakeData is a complete mesh that is then further processed and converted to a Quantum navmesh. The mesh is build in the way of a triangle strip |
| CNavMeshBakeDataLink | Creates a extra link between two triangles on the navmesh |
| CNavMeshBakeDataTriangle | Triangles are expected to have clock-wise winding order. Not all fields have to be filled out. Some of them are only needed for the legacy navmesh drawing tool |
| CNavMeshBakeDataVertex | Stores a 3D position |
| CNavMeshBaker | The NavMeshBaker turns the intermediate navmesh format NavMeshBakeData into a Quantum NavMesh |
| CNavMeshBakerBenchmarkerProgressBar | An implementation of the IProgressBar used for the navmesh baking. The internal baking process will set additional information on this class. The progress bar is only showed when the LogLevel is set to Debug |
| CNavMeshBorder | The navmesh border data structure |
| CNavMeshBorderGizmoEntry | Individual entry for specifically the border of the navmesh section of the gizmo overlay |
| CNavMeshBorderNode | The navmesh border node data structure that stores all borders inside a 2D grid for global raycasts for example |
| CNavMeshComponentGizmoEntry | Individual entry for specifically the NavMesh component section of the gizmo overlay |
| CNavMeshGizmoEntry | Individual entry for specifically the navmesh section of the gizmo overlay |
| CNavMeshLink | The navmesh link data structure |
| CNavMeshPathfinder | The NavMeshAgent is an entity component for automated navmesh navigation and steering. Use NavMeshPathfinder.Create(FrameBase, EntityRef, NavMeshAgentConfig) to create pathfinder components. Also see NavMesh and NavMeshAgentConfig |
| CNavMeshPortal | The Quantum navmesh stores connections between neighbouring triangles as portals |
| CNavMeshRegionMask | Internally stores a unsigned long to be able to toggle 128 different regions |
| CNavMeshSteeringAgent | A component to enable the steering toward a target position calculated by the navigation system. Requires NavMeshPathfinder component |
| CNavMeshTriangle | The navmesh triangle data structure |
| CNavMeshTriangleCenterGridNode | This grid stores one fallback triangle per cell |
| CNavMeshTriangleNode | A grid or all triangles used for quick lookups |
| CNavMeshVertex | The navmesh vertex data structure is saves as an array in the NavMesh.Vertices |
| CNonReorderableAttribute | A replacement for UnityEngine.NonReorderableAttribute |
| COptionalAttribute | Marks a field as optional. In Unity, the path passed will serve as the toggle to enable/disable |
| COptionalGizmoBool | Allows optional gizmo values to be serialized in the inspector |
| CPathUtils | Utility methods to work with folder and file paths |
| CPhotonServerSettings | This class wraps the AppSettings into a scriptable object and adds a few Quantum connection related configurations. Connect to specific region cloud: UseNameSever = true, FixedRegion = "us", Server = "" Connect to best region: UseNameSever = true, FixedRegion = "", Server = "" Connect to (local) master server: UseNameSever = false, FixedRegion = "", Server = "10.0.0.0.", Port = 5055 Connect to (local) name server: UseNameSever = true, FixedRegion = "", Server = "10.0.0.0.", Port = 5058 |
| CPhysicsBody2D | Adds physics motion to an entity with a PhysicsCollider2D driven by the built-in physics systems. You can customize how the movement of the physics body will works by changing the Mass, GravityScale or Drag. A Kinematic body will not have linear and angular velocities integrated, but those values are still perceived and taken into account when resolving the collision with other dynamic bodies |
| CPhysicsBody3D | Adds physics motion to an entity with a PhysicsCollider3D driven by the built-in physics systems. You can customize how the movement of the physics body will works by changing the Mass, GravityScale or Drag. A Kinematic body will not have linear and angular velocities integrated, but those values are still perceived and taken into account when resolving the collision with other dynamic bodies |
| CPhysicsCallbacks2D | A component that tracks the collisions (trigger and non-trigger) this entity is involved in. The tracked metadata is used to raise physics callbacks according to the callback Flags set |
| CPhysicsCallbacks3D | |
| CPhysicsCollider2D | A component with a shape used to represent 2D physics objects in the physics simulation. You can use flags and layers to setup how the object interacts with other colliders |
| CPhysicsCollider3D | A component with a shape used to represent 3D physics objects in the physics simulation. You can use flags and layers to setup how the object interacts with other colliders |
| CPhysicsComponentGizmoEntry | Individual entry for specifically the physics section of the gizmo overlay |
| ►CPhysicsJoints2D | A component holding one or more Physics2D.Joint, defining connections between a 2D Physics Body and anchors according to velocity and/or position constraints |
| CJointsIterator | An auxiliary struct to iterate over the joints on a PhysicsJoints2D component. Use PhysicsJoints2D.GetIterator to acquire an iterator for the component's joint buffer |
| ►CPhysicsJoints3D | A component holding one or more Joint3D, defining connections between a 3D Physics Body and anchors according to velocity and/or position constraints |
| CJointsIterator3D | An auxiliary struct to iterate over the joints on a PhysicsJoints3D component. Use PhysicsJoints3D.GetIterator to acquire an iterator for the component's joint buffer |
| CPhysicsMaterial | The Quantum's asset with the definitions for a PhysicsMaterialData |
| CPhysicsMaterialData | Defines the settings for a physics body to resolve its collision when it is touching another body |
| CPlayerRef | Represents a Quantum player |
| CPolygonCollider | The asset that contains data of a convex polygon |
| CPolygonColliderRuntimeData | The buffers with runtime data for the vertices and normals. They are loaded when the asset is added or replaced |
| CPreserveAttribute | A replacement for UnityEngine.Scripting.PreserveAttribute |
| CProgressBar | A progress bar implementation used by the navmesh importing. The progress bar is only showed when the LogLevel is set to Debug |
| CPropertyAttribute | A replacement for UnityEngine.PropertyAttribute |
| CPtr | The Ptr is a pointer wrapper to a memory location inside the frame heap |
| CQBoolean | Quantum boolean type that is stored on components |
| CQEnum16 | A variable sized enum field backed by a short value. The type helps with consistency and backwards compatibility when Enum types change during development |
| CQEnum32 | A variable sized enum field backed by a int value. The type helps with consistency and backwards compatibility when Enum types change during development |
| CQEnum64 | A variable sized enum field backed by a long value. The type helps with consistency and backwards compatibility when Enum types change during development |
| CQEnum8 | A variable sized enum field backed by a sbyte value. The type helps with consistency and backwards compatibility when Enum types change during development |
| CQString | Base class for DSL-generated variable QString(N) fields. QString supports UTF-16 (Unicode in .NET). N represents the total size of the string in bytes minus 2 bytes used for bookkeeping. In other words QString(64) will use 64 bytes for a string with a max byte length of 62 bytes, i.e. up to 31 UTF-16 characters |
| CQStringUtf8 | Base class for DSL-generated variable QString(N) fields. QStringUtf8 supports UTF-8. N represents the total size of the string in bytes minus 2 bytes used for bookkeeping. In other words QString(64) will use 64 bytes for a string with a max byte length of 62 bytes, i.e. up to 32 UTF-8 characters |
| CQuantumAddRuntimePlayers | Similar to the CustomCallback script and the QuantumRunnerLocalDebug this script will add all players inside the RuntimePlayer list as local players to Quantum during the game start. The script must Awake before starting the game and it works for local debug and online matches via a menu. Remove this script from your scene when the players are only added inside the menu classes (use the Player list in QuantumRunnerLocalDebug to start game scenes directly) |
| CQuantumAssetSourceResource | Resources-based implementation of the asset source pattern |
| CQuantumAssetSourceStatic | Hard reference-based implementation of the asset source pattern. This asset source forms a hard reference to the asset and never releases it. This type is meant to be used at runtime. For edit-time, prefer QuantumAssetSourceStaticLazy<T>, as it delays actually loading the asset, improving the editor performance |
| CQuantumAssetSourceStaticLazy | An edit-time optimised version of QuantumAssetSourceStatic<T>, taking advantage of Unity's lazy loading of assets. At runtime, this type behaves exactly like QuantumAssetSourceStatic<T>, except for the inability to use runtime-created objects |
| CQuantumCallback | Quantum callbacks are special types of events that are triggered internally by the Quantum simulation. For example CallbackUpdateView for Unity updates, CallbackPollInput that polls for player input. Use this class to subscribe and unsubscribe from Quantum callbacks |
| CQuantumCallbackHandler_DebugDraw | A handler object that registers to Quantum callbacks and draws debug shapes issued from the simulation |
| CQuantumCallbackHandler_FrameDiffer | A handler object to subscribe to Quantum callbacks to open the frame dump differ in builds after receiving a checksum error frame dumps |
| CQuantumCallbackHandler_GameResult | A handler object that subscribes to Quantum callbacks to send game results to the server |
| CQuantumCallbackHandler_LegacyQuantumCallback | A handler object that subscribes to Quantum callbacks to call legacy QuantumCallbacks in on Unity game objects |
| CQuantumCallbackHandler_StartRecording | A handler object that subscribes to Quantum callbacks to start recording input and checksums |
| CQuantumCallbackHandler_UnityCallbacks | A handler object that subscribes to Quantum callbacks to handle Unity scene loading and unloading |
| CQuantumCallbacks | A legacy way to hook into Quantum game callbacks. Use the publish subscribe pattern used by QuantumCallbacks instead. To use this callback class, derive from it and implement the methods you are interested in. The callback MonoBehaviour has to be added to the scene to work |
| CQuantumColor | Quantum default colors |
| CQuantumConsoleRunner | Simple command-line runner for Quantum simulations |
| CQuantumDebugInput | A Unity script that creates empty input for any Quantum game |
| CQuantumDefaultConfigs | This class represents a collection of Quantum config assets that are used when no explicit simulation config was assigned to a simulation (through RuntimeConfig). It's also implementing QuantumGlobalScriptableObject to have one instance globally accessible |
| CQuantumDefaultConfigsAssetPostprocessor | A Unity asset post processor that makes use to generate default Quantum configs in the user folder |
| CQuantumDeterministicSessionConfigAsset | The asset wraps an instance of DeterministicSessionConfig and makes it globally (in Unity) accessible as a default config |
| CQuantumEditorSettings | Contains global Quantum editor settings |
| ►CQuantumEntityPrototype | Entity Prototypes are similar to blueprints or prefabs, they carry information to create a Quantum Entity with its components and initialized them with pre-configured data |
| CInitialNavMeshTargetInfo | The initial navmesh target info |
| CNavMeshAvoidanceAgentInfo | Navmesh avoidance agent info |
| CNavMeshPathfinderInfo | The navmesh pathfinder info |
| CNavMeshSpec | Navmesh specification for prototypes |
| CNavMeshSteeringAgentInfo | Navmesh steering agent info |
| COverrideFP | Data object to store a bool and a fixed point to represent overriding default values |
| CPhysicsBodyGeneric | The all-purpose physics body info |
| CPhysicsColliderGeneric | A all-purpose physics collider info |
| CTransform2DVerticalInfo | Prototype settings for the Transform2DVertical component |
| ►CQuantumEntityView | The Quantum entity view component is the representation of the entity inside Unity. Instances will be created by the EntityViewUpdater. Quantum entity with the View component will references a Quantum EntityView asset which will in turn be instantiated as EntityView.Prefab and the resulting game object includes this script |
| CEntityUnityEvent | Wrapping UnityEvent(QuantumGame) into a class. Is used by the QuantumEntityView to make create and destroy publish Unity events |
| CUpdatePositionParameter | The struct is used to gather all transform and interpolation data to apply new transform data to the entity view. ApplyTransform(ref UpdatePositionParameter) |
| CQuantumEntityViewComponent | The base class to inherit entity view components from. Entity view components can be used to add features to entity views and gain simple access to all relevant Quantum game API and the Quantum entity |
| CQuantumEntityViewPool | An implementation of a EntityView pool to be used with the QuantumEntityViewUpdater.Pool. Add this behaviour to the same game object that the QuantumEntityViewUpdater behaviour is on. Using QuantumCallback.Subscribe() with pooled objects as listener needs to use the onlyIfActiveAndEnabled option to not be callbacks from disabled pooled objects |
| CQuantumEntityViewUpdater | The Entity View Updater is essential. An instance needs to be present to create Entity Views as the simulation view representations based on the Quantum.EntityView components |
| CQuantumEvent | Events are a fire-and-forget mechanism to transfer information from the simulation to the view. Use this class to subscribe and unsubscribe from Quantum events |
| CQuantumFrameDiffer | The frame differ shows the frame dumps of all clients in a game and allows to compare them after a checksum error. This class renders the GUI on the screen and is usable in builds |
| ►CQuantumFrameDifferGUI | The actual GUI to render the frame dumps differences of multiple dumps send by different clients. Uses Unity Immediate Mode GUI |
| CFrameDifferState | The state saves multiple frame dumps |
| ►CQuantumGame | QuantumGame acts as an interface to the simulation from the client code's perspective |
| CCallbackBase | The base class of Quantum callbacks |
| CConfigurationsContainer | Stores runtime config and simulation config for this session |
| CFramesContainer | Stores the different frames the simulation uses during one tick |
| CQuantumGameFlags | This class contains values for flags that will be accessible with QuantumGame.GameFlags. Built-in flags control some aspects of QuantumGame inner workings, without affecting the simulation outcome |
| CQuantumGameGizmosSettings | The gizmo settings for the Quantum game |
| CQuantumGameGizmosSettingsScriptableObject | A scriptable object to store the Quantum game gizmos settings QuantumGameGizmosSettings. Global configs are marked with "QuantumDefaultGlobal" asset label and there should be only one instance of this asset tagged as such |
| CQuantumGameStartParameters | Parameters required to start a Quantum game |
| CQuantumGizmoColors | The default Quantum Gizmo colors |
| CQuantumGizmoEntry | Individual entry for a specific section of Quantum |
| CQuantumGizmoStyle | The style of the gizmo |
| CQuantumGlobalScriptableObject | A base class for ScriptableObjects that are meant to be globally accessible, at edit-time and runtime. The way such objects are loaded is driven by usages of QuantumGlobalScriptableObjectSourceAttribute attributes |
| CQuantumGlobalScriptableObjectAddressAttribute | If applied at the assembly level, allows QuantumGlobalScriptableObject<T> to be loaded with Addressables |
| CQuantumGlobalScriptableObjectAttribute | Provides additional information for a global scriptable object |
| CQuantumGlobalScriptableObjectLoadResult | The result of QuantumGlobalScriptableObjectSourceAttribute.Load. Contains the loaded object and an optional unloader delegate |
| CQuantumGlobalScriptableObjectResourceAttribute | If applied at the assembly level, allows QuantumGlobalScriptableObject<T> to be loaded with Resources. There is a default registration for this attribute, which attempts to load the asset from Resources using path from QuantumGlobalScriptableObjectAttribute |
| CQuantumGlobalScriptableObjectSourceAttribute | Base class for all attributes that can be used to load QuantumGlobalScriptableObject. Attributes need to be registered at the assembly level. For instance, this snippet is used to register a default loader, that attempts to load from Resources based on QuantumGlobalScriptableObjectAttribute.DefaultPath: |
| CQuantumInputHistoryData | Input history wrapper to used to store on replay files. Default way to save is DeltaCompressed in Json with compression to reduce the (Json) file size the most |
| CQuantumInstantReplay | The instant replay feature. It can be used as is or used as a base class for custom instant replay implementations |
| CQuantumInstantReplayDemo | A script to demonstrate the instant replay feature of Quantum. Add this script to a GameObject in your scene to enable the instant replays. Press the "Start" button during runtime to start a replay. Uses the QuantumInstantReplay class |
| CQuantumJsonFriendlyDataBlob | Wrapper around storing binary data in JSON to work around the problem that Unity JSON tools only serialize byte arrays verbosely |
| CQuantumLoadBalancingClient | Obsolete: Not used anymore. Replace by using RealtimeClient directly |
| CQuantumLogInitializer | Initializes the logging system for Quantum. Use InitializeUser to completely override the log level and trace channels or to provide a custom logger. Use InitializeUnityLoggerUser to override default Unity logger settings |
| CQuantumMapBakeAssemblyAttribute | This assembly attribute needs to be set inside custom assemblies that required static edit mode callbacks from the MapDataBakerCallback class. [assembly: QuantumMapBakeAssembly] |
| CQuantumMapData | Unity component that holds and bakes the map data for a Quantum map from a given scene |
| CQuantumMapLoader | A Unity script that helps with loading Quantum maps and scenes |
| CQuantumMemoryStats | A script that displays memory stats of the Quantum heap |
| CQuantumMenuSceneInfo | Info asset for creating configurable selectable scenes in the Photon menu. This type was moved to the SDK to simplify adding scenes automatically (e.g. when installing another unity package) |
| CQuantumMeshCollection | A collection of Unity mesh asset to draw gizmos or scene object |
| CQuantumMonoBehaviour | Base class for all Quantum MonoBehaviours |
| CQuantumMppm | Support for Multiplayer Play Mode (MPPM). It uses named pipes to communicate between the main Unity instance and virtual instances |
| CQuantumMppmCommand | The base class for all Quantum MPPM commands |
| CQuantumMultiClientPlayer | This class keeps track of individual Photon connections and Quantum simulations (QuantumRunner) |
| CQuantumMultiClientPlayerView | The multi client UI view of one player |
| CQuantumMultiClientRunner | The script will can manage multiple online clients and Quantum players in your Editor. This means the remote view of your player can be visualized in the same Unity instance. Minimum settings: |
| ►CQuantumNavMesh | This class is a collection of utility methods to import Unity NavMesh data into Quantum NavMesh data |
| CImportSettings | The Unity navmesh import settings |
| CQuantumNavMeshDebugDrawer | Obsolete script. Navmesh editor gizmos are now rendered with the map |
| CQuantumNavMeshRegion | This script can be placed on a game object that has a mesh renderer and is used to cast Quantum navmesh toggle-able regions onto the Unity generated navmesh |
| CQuantumNetworkCommunicator | This class implements the Quantum interface ICommunicator and uses Photon Realtime in Unity to support sending RaiseEvent(byte, byte[], int, bool, int[]) and receiving AddEventListener(Photon.Deterministic.OnEventReceived) network messages from the Photon Cloud |
| CQuantumPlayerLoopSystemHandle | Represents a system that has been added to the PlayerLoopSystem |
| CQuantumPlayerLoopSystemUtils | Utility class for manipulating Unity Player Loop System |
| CQuantumReconnectInformation | Implements MatchmakingReconnectInformation to save reconnect information to player prefs. This way the app can try to reconnect after app start |
| CQuantumReplayFile | A class that holds all relevant data to run a Quantum replay and can serialized in JSON. A replay may contain an asset db for convenience, that should be omitted in production environments where files sizes are a concern. A replay may contain recorded checksums, that can be verified during runtime as a development feature |
| CQuantumRunnerBehaviour | A unity script that updates the Quantum runner. Also manages calls to Gizmos and DebugDraw required to render Quantum debug gizmos. If you are writing a custom SRP, you must call RenderPipeline.EndCameraRendering to trigger OnPostRenderInternal() |
| ►CQuantumRunnerLocalDebug | A debug script that starts the Quantum simulation for MaxPlayerCount players when starting the game from a gameplay scene. Will add LocalPlayers as local players during simulation start. The script will disable itself when it detects that other scene were loaded before this (to delegate adding players to a menu scene / game bootstrap) |
| ►CDynamicAssetDBSettings | Settings used to initialize the dynamic db |
| CInitialDynamicAssetsRequestedUnityEvent | A unity event passing the dynamic asset db |
| CQuantumRunnerLocalReplay | An example of how to start a Quantum replay simulation from a replay file |
| CQuantumRunnerLocalSavegame | This script can be used to start a Quantum simulation from a savegame file and is very similar to QuantumRunnerLocalReplay |
| CQuantumRunnerRegistry | A registry to keep track of all active Quantum runners |
| CQuantumRunnerUnityFactory | Implements the runner factory to Unity platform |
| CQuantumSceneViewComponent | The SceneViewComponent is able to attach itself to the QuantumEntityViewUpdater and received updates from it |
| CQuantumScriptableObject | Base class for all Quantum scriptable objects |
| ►CQuantumSnapshotInterpolationTimer | Configuration of the snapshot interpolation mode when selected in QuantumEntityView.InterpolationMode |
| CInterpolationBuffer | Simple ring buffer to store transform data |
| CQuantumTransformData | Data structure to hold transform data on an entity in a buffer |
| CQuantumStaticBoxCollider2D | The script will create a static 2D Quantum box collider during map baking |
| CQuantumStaticBoxCollider3D | The script will create a static 3D Quantum box collider during map baking |
| CQuantumStaticCapsuleCollider2D | The script will create a static 2D capsule collider during Quantum map baking |
| CQuantumStaticCapsuleCollider3D | The script will create a static 3D capsule collider during Quantum map baking |
| CQuantumStaticCircleCollider2D | The script will create a static 2D circle collider during Quantum map baking |
| CQuantumStaticEdgeCollider2D | The script will create a static 2D edge collider during Quantum map baking |
| CQuantumStaticMeshCollider3D | The script will create a static 3D mesh collider during Quantum map baking |
| CQuantumStaticPolygonCollider2D | The script will create a static 2D polygon collider during Quantum map baking |
| CQuantumStaticSphereCollider3D | The script will create a static sphere collider during Quantum map baking |
| CQuantumStaticTerrainCollider3D | The script will create a static 3D terrain collider during Quantum map baking |
| CQuantumStats | Measures and display basic Quantum statistics on a UI element |
| CQuantumUnityCallbackDispatcher | Quantum.CallbackDispatcher implementation for Unity. Adds Unity specific callback types. Additional user callback types can be added via partial method |
| ►CQuantumUnityDB | At runtime, servers as the default implementation of IResourceManager for Unity. During edit time, it collects and keeps track of all the AssetObject assets in the project. Collected assets are stored as IQuantumAssetObjectSource references, avoiding forming hard-references to the actual assets (if possible) |
| CEntry | Internal representation of an asset in the DB. Serialized data remains immutable, while the runtime data is mutable |
| CQuantumUnityEventDispatcher | Quantum.EventDispatcher implementation for Unity |
| CQuantumUnityExtensions | Provides backwards compatibility for Unity API |
| CQuantumUnityInputSystemWithLegacyFallback | This script simplifies the transition between the new Unity Input System and the legacy Input Manager |
| ►CQuantumUnityJsonSerializer | Asset serializer implementation based on UnityEngine.JsonUtility and a set of utility methods from JsonUtilityExtensions. Can use surrogates to replace asset types with more efficient representations (RegisterSurrogate<AssetType,SurrogateType>. Additionally, any Unity-object references are serialized as null by default (NullifyUnityObjectReferences). The output can be deserialized with Newtonsoft.Json-based deserializer from Quantum.Json assembly. If this interoperability is needed, consider enabling IntegerEnquotingMinDigits to ensure that large integers are enquoted and not treated as floating points |
| CAssetObjectSurrogate | Base class for asset object surrogates |
| CBinaryDataSurrogate | Quantum.BinaryData surrogate. Compresses the data if it is larger than the threshold and replaces the data with a base64 encoded string |
| CEntityViewSurrogate | Quantum.EntityView surrogate. Does not serialize the prefab reference, but only the identifier. QuantumUnityJsonSerializer.ResolvePrefab is used to resolve the prefab during deserialization |
| CQuantumUnityLogger | |
| CQuantumUnityNativeAllocator | The Unity implementation of the Quantum native memory allocator |
| CQuantumUnityNativeUtility | The Unity implementation of the Quantum native utility functions |
| CQuantumUnityStaticDispatcherAdapter | Adapter for static dispatchers in Unity. Provides utility static methods, internal worker that removes dead listeners and means for creating a dispatcher |
| CQuantumUserGizmoEntry | User defined gizmo entry |
| CQuantumViewComponent | The base class to inherit entity view components from. Entity view components can be used to add features to entity views and gain simple access to all relevant Quantum game API and the Quantum entity. The view component is not updated (OnUpdateView, OnLateUpdateView) if the behaviour has been disabled |
| CQUnityComponentPrototypeRef | Obsolete, still defined to prevent data loss |
| CRangeAttribute | A replacement for UnityEngine.RangeAttribute |
| CRangeExAttribute | Represents an attribute that specifies a range of values for a field or property |
| CReadOnlyAttribute | Attribute used to mark a field as read-only |
| ►CReflectionUtils | Quantum reflection utilities |
| CTypeHierarchyComparer | Comparer for types for sorting |
| CReplayFile | Obsolete class, use QuantumReplayFile instead |
| CResourceManagerStatic | A static resource manager that can be used to manage assets in a deterministic context. All the assets are known and instantiated ahead of time |
| CRingBufferInputProvider | This input provider can store a certain amount of input sets in a ring buffer |
| CRotation2DAttribute | Marks a FP/NullableFP field as a 2D rotation angle |
| CRuntimeConfig | In contrast to the SimulationConfig, which has only static configuration data, the RuntimeConfig holds information that can be different from game to game |
| CScenePathAttribute | Specifies that a string field represents a scene path |
| CScriptHelpAttribute | Defines the appearance of the script header in the Unity inspector |
| CSerializableType | A System.Type wrapper that can be serialized |
| CSerializableTypeAttribute | Specifies that either a string field represents a type name or sets additional options for SerializableType field |
| CSerializeField | A replacement for UnityEngine.SerializeField |
| CSerializeReference | A replacement for UnityEngine.SerializeReference |
| CSerializeReferenceTypePickerAttribute | Attribute used to show a type picker for a field with [SerializeReference] |
| ►CSessionRunner | The SessionRunner helps to start, run and shutdown a Quantum simulation. It should never be reused for multiple simulations of multiple runs of the same game session. Always recrate the runner. It has an extensive list of starting Arguments that make it start-able for a variety of use cases: Local, Multiplayer, Replay, Server etc It extracts platform dependent code into the IRunnerFactory parameter. It offers asynchronous methods to start and stop the runner but although it uses the TPL syntax for convenience it is not considered to be run in a multi-threaded environment. Use the non-async versions of the methods or use a ConcurrentExclusiveSchedulerPair.ExclusiveScheduler for unit tests and console applications. Also never use the async methods from the Quantum server plugin, parallelization is done by the Photon-Server. This class is delivered in source code to enable developers to create custom runner code |
| CArguments | Arguments to start an online or offline Quantum simulation |
| CSessionRunnerException | Runner specific exceptions |
| ►CShape2D | Defines a 2D shape with Type and data disposed in a union-like structure. All shapes have a UserTag, BroadRadius and Centroid. All non-compound shapes have a LocalTransform and their Centroid always match their local transform position |
| CBoxShape | Defines a 2D box in its local space. In order to create a Shape2D of type Shape2DType.Box, use Shape2D.CreateBox.
|
| CCapsuleShape | Defines a 2D capsule in its local space. In order to create a Shape2D of type Shape2DType.Capsule, use Shape2D.CreateCapsule.
|
| CCircleShape | Defines a 2D circle in its local space. In order to create a Shape2D of type Shape2DType.Circle, use Shape2D.CreateCircle.
|
| CCompoundShape2D | A 2D shape type that can reference a group of other 2D shapes (including other compounds). Compound shape overlaps and physics colliders with compound shapes are supported |
| CEdgeShape | Defines a 2D edge in its local space. In order to create a Shape2D of type Shape2DType.Edge, use Shape2D.CreateEdge.
|
| CPolygonShape | References a Polygin shape by the AssetRef<T> of its Quantum.PolygonCollider asset |
| ►CShape2DConfig | The base settings for building a Shape2D |
| CCompoundShapeData2D | The settings of each shape in the compound of shapes list |
| ►CShape3D | Defines a 3D shape with Type and data disposed in a union-like structure. All shapes have a UserTag, BroadRadius and Centroid. All non-compound shapes have a LocalTransform and their Centroid always match their local transform position |
| CBoxShape | Defines a 3D box shape in its local space. In order to create a Shape3D of type Shape3DType.Box, use Shape3D.CreateBox.
|
| CCapsuleShape | Defines a 3D capsule shape in its local space. In order to create a Shape3D of type Shape3DType.Capsule, use Shape3D.CreateCapsule.
|
| CCompoundShape3D | A 3D shape type that can reference a group of other 3D shapes (including other compounds, but not Mesh and Terrain shapes). Compound shape overlaps and physics colliders with compound shapes are supported |
| CMeshShape | References a static Mesh collider by its index |
| CSphereShape | Defines a sphere shape in its local space. In order to create a Shape3D of type Shape3DType.Sphere, use Shape3D.CreateSphere.
|
| CTerrainShape | References a static Terrain shape by its Quantum.TerrainCollider asset |
| ►CShape3DConfig | The base settings for building a Shape3D |
| CCompoundShapeData3D | The settings of each shape in the compound of shapes list |
| CSimulationConfig | The SimulationConfig holds parameters used in the ECS layer and inside core systems like physics and navigation |
| CSpaceAttribute | A replacement for UnityEngine.SpaceAttribute |
| CStaticColliderData | Information about a static collider |
| CStatics | Static type registry is completed by code generation |
| CStreamReplayInputProvider | The stream replay input provider is used to play back input from a stream |
| CStructPrototype | Base class for DSL code-generated structs. The fields will be ordered in alphabetical order when the struct is generated |
| CSystemBase | The Quantum system base class |
| CSystemGroup | The base class for a hierarchy of systems |
| CSystemMainThread | Most common Quantum system type. Implements a regular Update() with all the usual features |
| CSystemMainThreadFilter | This type of system uses a FilterStruct of type T to filter a set of entities based on it, loop through them and calls a method |
| CSystemMainThreadGroup | A Quantum main thread system that has a system hierarchy |
| ►CSystemsConfig | A Quantum configuration asset that will create and start Quantum systems in a data-driven way when starting the simulation. Can be assigned to RuntimeConfig. If no config is assigned then a default selection of build-in systems is used (DeterministicSystemSetup.CreateSystems(RuntimeConfig, SimulationConfig, SystemsConfig). The systems to be used can always be changed by code inside DeterministicSystemSetup.AddSystemsUser(ICollection<SystemBase>, RuntimeConfig, SimulationConfig, SystemsConfig) |
| CSubSubSystemEntry | 2nd sub level system type |
| CSubSystemEntry | 1st sub level system type |
| CSystemEntry | Base system type |
| CSystemEntryBase | To prevent indefinite recursion in Unity serialization system hierarchies are limited to 3 levels |
| CSystemEntryBase | System that will be instantiated on simulation start |
| CSystemSignalsOnly | This type of system does not have an Update() function. It is meant for systems that focus solely on implementing and receiving signals from other systems. By avoiding the Update loop, it helps you save some overhead |
| CTextWriterLogger | Not used anymore |
| CTextWriterLogStream | A log stream that writes log messages to a TextWriter |
| CToggleLeftAttribute | Specifies that the bool field should be drawn as the toggle on the left side of the label |
| CTooltipAttribute | A replacement for UnityEngine.TooltipAttribute |
| CTransform2D | The Transform2D is an entity component providing position and rotation a 2D object |
| CTransform2DVertical | The Transform2DVertical is an entity component pseudo-3D height and offset for an entity |
| CTransform3D | The Transform3D is an entity component providing position and rotation for a 3D object |
| ►CTriangleMesh | The data representation of all static triangles in the scene |
| CCellBounds | The bounds of a cell |
| CTriangleReference | Represents a reference to a triangle in the triangle mesh |
| CTriggerInfo2D | Info about a collision between a trigger and a non-trigger 2D physics colliders |
| CTriggerInfo3D | Info about a collision between a trigger and a non-trigger 3D physics colliders |
| CTypeRegistry | The Quantum type registry |
| CTypeUtils | Type reflection utility methods. Is generally slow |
| CUnionPrototype | Base class for DSL code-generated union structs. The union type overlaps in memory the data layout of all the involved structs. Unions can be declared as part of a component. Internally, the union type Data contains the logic necessary for switching between the union types as they are accessed |
| CUnitAttribute | Unit Attribute class. Used to mark a field with the respective Units |
| CUnityAddressablesRuntimeKeyAttribute | Specifies that the string field represents a key for Unity Addressables |
| CUnityAssetGuidAttribute | Specifies that the string field represents a GUID of an asset |
| CUnityResourcePathAttribute | Specifies that the string field represents a path to a Unity resource |
| CView | Quantum component used to reference an EntityView asset which represents the view object that is created and updated in runtime, usually used for displaying entity graphics |
| CWarnIfAttribute | Editor attribute for adding notices to fields if the condition member evaluates as true. Condition member can be a property, field or method (with a return value) |
| ►NQuantumUser | |
| ►NSystem | |
| ►NDiagnostics | |
| ►NUnityEngine | |
| CAssetDB | Represents an asset database |
| CAssetObjectQuery | Represents a query for asset objects in the resource manager |
| CComponentSet | A bitset representing a set of components. The set can contain up to 512 components. This type is not serializable, as any defining or removing a component type would affect other component indices |
| CComponentTypeRef | A persistent and serializable reference to a component type. Is valid as long as the component type is not renamed |
| CDictionaryEntry | A base class for dictionary entries. For maximum compatibility with Unity, dictionaries in prototypes are serialized as an array of entries, rather than a dictionary |
| CHostProfiler | Provides profiling functionality for the host. It used to measure different parts of the engine compared to Profiler, which in turn is used to measure the performance at finer granularity |
| CIGameResult | Represents the result of a game |
| CIgnoreInAssetObjectCheckAttribute | Helper attribute used in Quantum migration |
| CIHostProfiler | Interface for the host profiler |
| CIRuntimeConfig | Represents the runtime configuration for the Quantum engine |
| CIRuntimePlayer | Represents a runtime player |
| CISerializationCallbackReceiver | A replacement for UnityEngine.ISerializationCallbackReceiver |
| CLastSupportedVersionAttribute | Marks the last Quantum version that supports the attributed type/method/property/field |
| CQuantumJsonSerializer | A serializer that is able to deserialize JSON produced by QuantumUnityJsonSerializer. Handles SerializeReference, Unity-style byte[] serialization and fixed-size buffers. Uses UnityJsonUtilityConvert under the hood |