Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 1234]

►CPhoton.Deterministic.Native.Allocator	Represents native memory allocations and is used in many places across the engine
►CPhoton.Deterministic.Native.PInvokeAllocator	A specific allocator that tracks allocations in Debug mode
CPhoton.Deterministic.Native.LIBCAllocator	The libc native allocator implementation
CPhoton.Deterministic.Native.MSVCRTAllocator	The MSVCRT native allocator implementation
CQuantum.QuantumUnityNativeAllocator	The Unity implementation of the Quantum native memory allocator
CPhoton.Deterministic.Native.AllocatorVTable	Equal to the AllocatorVTableManaged but with marshaled function pointers
CPhoton.Deterministic.Native.AllocatorVTableManaged	A class that wraps memory allocation methods to be used in native code parts of the engine
CQuantum.Physics2D.PhysicsEngine2D.Api	2D Physics API
CQuantum.Physics3D.PhysicsEngine3D.Api	3D Physics API
CQuantum.Core.FrameContext.Args	The FrameContext creating arguments
CQuantum.SessionRunner.Arguments	Arguments to start an online or offline Quantum simulation
CQuantum.ArrayUtils	A collection of utility methods for working with arrays
CQuantum.Assert	Provides methods for asserting conditions. Throws an AssertException when a condition is not met. Methods are only invoked in DEBUG builds unless otherwise specified
CQuantum.AssertException	An exception that is thrown when an assertion fails
CQuantum.Editor.AssetDatabaseUtils	Utility methods for working with Unity's AssetDatabase
CAssetDB	Represents an asset database
CQuantum.Editor.AssetDatabaseUtils.AssetEnumerable	Enumerable of assets in the project that match the given search criteria
CQuantum.Editor.AssetDatabaseUtils.AssetEnumerator	Enumerates assets in the project that match the given search criteria using HierarchyProperty API. Obtained with AssetDatabaseUtils.IterateAssets
CQuantum.AssetGuid	Represents a unique identifier for an asset
CQuantum.AssetObjectIdentifier	A struct that identifies an asset object by either its GUID and (optionally) path
CAssetObjectQuery	Represents a query for asset objects in the resource manager
►CQuantum.QuantumUnityJsonSerializer.AssetObjectSurrogate	Base class for asset object surrogates
CQuantum.QuantumUnityJsonSerializer.BinaryDataSurrogate	Quantum.BinaryData surrogate. Compresses the data if it is larger than the threshold and replaces the data with a base64 encoded string
CQuantum.QuantumUnityJsonSerializer.EntityViewSurrogate	Quantum.EntityView surrogate. Does not serialize the prefab reference, but only the identifier. QuantumUnityJsonSerializer.ResolvePrefab is used to resolve the prefab during deserialization
CQuantum.AssetRef	An indirect reference to an AssetObject
CQuantum.AssetRef< T >	An indirect reference to an AssetObject of type T
CQuantum.AssetRef< EntityView >
CQuantum.AssetRef< Quantum.EntityView >
CQuantum.AssetRef< Quantum.Quantum.EntityPrototype >
CQuantum.AssetRef< Quantum.Quantum.NavMesh >
CQuantum.AssetRef< Quantum.Quantum.NavMeshAgentConfig >
CQuantum.AssetRef< Quantum.Quantum.PhysicsMaterial >
CQuantum.AssetRef< Quantum.BinaryData >
CQuantum.AssetRef< Quantum.CharacterController2DConfig >
CQuantum.AssetRef< Quantum.CharacterController3DConfig >
CQuantum.AssetRef< Quantum.Map >
CQuantum.AssetRef< Quantum.NavMesh >
CQuantum.AssetRef< Quantum.NavMeshAgentConfig >
CQuantum.AssetRef< Quantum.PhysicsMaterial >
CQuantum.AssetRef< Quantum.PolygonCollider >
CQuantum.AssetRef< Quantum.SimulationConfig >
CQuantum.AssetRef< Quantum.SystemsConfig >
CQuantum.AssetRef< TerrainCollider >
CQuantum.BinaryData	An asset containing raw binary data. Use CreateByteStream to access contents safely and auto-decompress, if compressed
CQuantum.BitSet1024	A bitmask with 1024 bits
CQuantum.BitSetRef	A variable sized bitmask
CPhoton.Deterministic.BitStream	Writes information at the bit level to a byte array
CQuantum.BitStreamExtensionsCore	Bit steam extensions methods to serialize Quantum specific concrete types
CQuantum.Shape2D.BoxShape	Defines a 2D box in its local space. In order to create a Shape2D of type Shape2DType.Box, use Shape2D.CreateBox. See also Shape2D, Shape2DType
CQuantum.Shape3D.BoxShape	Defines a 3D box shape in its local space. In order to create a Shape3D of type Shape3DType.Box, use Shape3D.CreateBox. See also Shape3D, Shape3DType
CQuantum.Button	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
CQuantum.Json.ByteArrayConverter	Converts byte arrays to and from JSON in a way compatible with the Unity's built-in JSON utility
CQuantum.ByteSerializerHashMapper< T >	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
CQuantum.ByteSerializerHashMapper< FPVector3RawInt >
CQuantum.ByteStream	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
CQuantum.ByteStreamExtension	Byte stream extension methods
CPhoton.Deterministic.ByteUtils	Utility class for working with bytes
CQuantum.Shape2D.CapsuleShape	Defines a 2D capsule in its local space. In order to create a Shape2D of type Shape2DType.Capsule, use Shape2D.CreateCapsule. See also Shape2D, Shape2DType
CQuantum.Shape3D.CapsuleShape	Defines a 3D capsule shape in its local space. In order to create a Shape3D of type Shape3DType.Capsule, use Shape3D.CreateCapsule. See also Shape3D, Shape3DType
CQuantum.TriangleMesh.CellBounds	The bounds of a cell
CQuantum.CharacterController2DConfig	The configuration values of the CharacterController2D. Use this to setup the kcc shape size and tune its movement and collision detection
CQuantum.CharacterController2DMovement	Result of a 2D KCC raw movement query
CQuantum.Prototypes.CharacterController2DPrototype	Prototype of the CharacterController2D Quantum component
CQuantum.CharacterController3DConfig	The configuration values of the CharacterController3D. Use this to setup the kcc shape size and tune its movement and collision detection
CQuantum.CharacterController3DMovement	Result of a 3D KCC raw movement query
CQuantum.Prototypes.CharacterController3DPrototype	Prototype of the CharacterController3D Quantum component
CQuantum.ChecksumFile.ChecksumEntry	Represents one recorded checksum
CPhoton.Deterministic.ChecksumErrorFrameDump	A class that accumulates frame dumps from other clients during a checksum desync
CQuantum.ChecksumErrorFrameDumpContext	Gathers additional meta data during the Quantum game callback IDeterministicGame.GetExtraErrorFrameDumpData in response to a checksum error
CQuantum.ChecksumFile	A serializable object that contains recorded checksums for a Quantum session
CQuantum.ChecksumFileHelper	Helper methods to convert between ulong and long
CQuantum.Shape2D.CircleShape	Defines a 2D circle in its local space. In order to create a Shape2D of type Shape2DType.Circle, use Shape2D.CreateCircle. See also Shape2D, Shape2DType
CQuantum.CollisionInfo2D	Info about a collision between two 2D physics colliders
CQuantum.CollisionInfo3D	Info about a collision between two 3D physics colliders
CQuantum.Physics2D.CollisionResultInfo2D	A structure for containing all the result information from the collision between two shapes
CQuantum.ColorRGBA	Quantum representation of a color with 4 channels (R, G, B, A) each represented by a byte
CPhoton.Deterministic.FP.Comparer	Compares FPs
CQuantum.ComponentBlockIterator< T >	Component block iterators give the fastest possible access via pointers
CQuantum.ComponentCallbacks	Component callbacks
CQuantum.ComponentFilter< T0, T1 >	Filter entities by component types
CQuantum.ComponentFilter< T0 >	Filter entities by component types
CQuantum.ComponentFilter< T0, T1, T2 >	Filter entities by component types
CQuantum.ComponentFilter< T0, T1, T2, T3 >	Filter entities by component types
CQuantum.ComponentFilter< T0, T1, T2, T3, T4 >	Filter entities by component types
CQuantum.ComponentFilter< T0, T1, T2, T3, T4, T5, T6, T7 >	Filter entities by component types
CQuantum.ComponentFilter< T0, T1, T2, T3, T4, T5 >	Filter entities by component types
CQuantum.ComponentFilter< T0, T1, T2, T3, T4, T5, T6 >	Filter entities by component types
CQuantum.ComponentFilterStruct< T >	Component filter
CQuantum.ComponentFilterStructMeta	Component filter that is initialized from a filter class having component fields
CQuantum.ComponentPrototypeRef	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
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
CQuantum.ComponentTypeId	Runtime information for component types, containing their ID, size, flags and callbacks
CQuantum.ComponentTypeId< T >	Runtime information for a component type, containing its ID, size, flags and callbacks
CComponentTypeRef	A persistent and serializable reference to a component type. Is valid as long as the component type is not renamed
CQuantum.ComponentTypeSetSelector	Represents a set of component types. Use ComponentTypeRef array insteadd
CQuantum.Shape2D.CompoundShape2D	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
CQuantum.Shape3D.CompoundShape3D	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
CQuantum.Shape2DConfig.CompoundShapeData2D	The settings of each shape in the compound of shapes list
CQuantum.Shape3DConfig.CompoundShapeData3D	The settings of each shape in the compound of shapes list
CQuantum.Navigation.Config	Global navmesh configurations which are part of the SimulationConfig
CQuantum.PhysicsCommon.Config	Global physics settings which are part of the SimulationConfig
CQuantum.Allocator.Heap.Config	The configuration of the frame heap
CPhoton.Deterministic.ConfigParsingExtensions	Used by the server to parse the config information
CQuantum.QuantumGame.ConfigurationsContainer	Stores runtime config and simulation config for this session
CQuantum.Navigation.Constants	Global navigation constants
CQuantum.CollisionInfo2D.ContactPointIterator2D	A helper for safety interaction through the contact point buffer
CQuantum.CollisionInfo3D.ContactPointIterator3D	An iterator over multiple triangles collisions with a given mesh
CQuantum.ContextMenuAttribute	A replacement for UnityEngine.ContextMenuAttribute
CPhoton.Deterministic.DeterministicTickInput.CorruptedException	The corrupted exception is thrown when error during the deserialization are detected
CQuantum.CreateAssetMenuAttribute	A replacement for UnityEngine.CreateAssetMenuAttribute
CQuantum.Core.FrameBase.Culling	The Culling class handles the scheduling of culling tasks
CQuantum.Draw.DebugBox	Stores information to draw the debug shape box
CQuantum.Draw.DebugCapsule	Stores information to draw the debug shape capsule
CQuantum.Draw.DebugCircle	Stores information to draw the debug shape circle
CQuantum.Core.DebugCommand	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
CQuantum.Core.DebugCommandType	Predefined debug commands
CQuantum.DebugDraw	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
CQuantum.Draw.DebugLine	Stores information to draw the debug shape line
CQuantum.DebugMesh	Access to Quantum debug mesh resources. Obsolete: has been replaced by QuantumMeshCollection.Global
CQuantum.Draw.DebugRay	Stores information to draw the debug shape ray
CQuantum.Draw.DebugRectangle	Stores information to draw the debug shape rectangle
CQuantum.Draw.DebugSphere	Stores information to draw the debug shape sphere
CPhoton.Deterministic.DeterministicChecksumResult	The data checksum is used to verify the integrity of the simulation
CPhoton.Deterministic.DeterministicCommandSerializer	The DeterministicCommandSerializer is used to serialize and de-serialize DeterministicCommands
CQuantum.DeterministicCommandSetup	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
CPhoton.Deterministic.DeterministicFrame	The base class for the simulation frame. Also referred as rollback-able game state
CPhoton.Deterministic.DeterministicFrameInputTemp	A struct that saves input data for a player duplicating internal input data that is not save to use because of recycling
CPhoton.Deterministic.DeterministicFrameRingBuffer	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
CPhoton.Deterministic.DeterministicInput	Obsolete type
CPhoton.Deterministic.DeterministicPlatformInfo	Essential platform dependent information and implementations
CPhoton.Deterministic.DeterministicPlayerMap	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
CPhoton.Deterministic.DeterministicPlugin	Override the Quantum plugin class to create a custom server object
CPhoton.Deterministic.Server.DeterministicPluginClient	The client representation in the Quantum server plugin
CPhoton.Deterministic.DeterministicPluginFactory	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
CPhoton.Deterministic.Server.DeterministicPluginSession	The session object of the Quantum server plugin. Only one session is being created by one DeterministicServer
CPhoton.Deterministic.DeterministicProtocolVersionAttribute	The assembly attribute to specify the deterministic protocol version
CPhoton.Deterministic.Server.DeterministicServer	The Quantum server class. Override virtual methods to extend its functionality
CPhoton.Deterministic.DeterministicSession	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
CPhoton.Deterministic.DeterministicSessionArgs	Represents the starting arguments for a deterministic constructor
CPhoton.Deterministic.DeterministicSessionConfig	Parameterize internals of the Deterministic simulation and plugin (the Quantum server component)
CPhoton.Deterministic.Webhooks.DeterministicSessionConfigJsonConverter	A custom JsonConverter for the DeterministicSessionConfig object. The class contains fields that need to be serialized which in only available in net5.0
CPhoton.Deterministic.DeterministicStats	Deterministic simulation statistic
CQuantum.DeterministicSystemSetup	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
CPhoton.Deterministic.DeterministicTickChecksum	An object that contains a tick and a checksum
CPhoton.Deterministic.DeterministicTickChecksumError	A collection of checksums when an error was recognized
CPhoton.Deterministic.DeterministicTickInput	The internal input structure for one player and one tick
CPhoton.Deterministic.DeterministicTickInputDecoder	The decoder helps to deserialize the input from the server
CPhoton.Deterministic.DeterministicTickInputEncodeHeader	Input header information
CPhoton.Deterministic.DeterministicTickInputSet	The complete input set of all players for a single tick
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
►CQuantum.DispatcherBase	Base class for dispatchers. Dispatchers are used to publish and subscribe to events represented by IDispatchable objects
►CQuantum.CallbackDispatcher	A subscribe and publish pattern for Quantum callbacks. A Quantum callback is a invocation from inside the simulation during certain situations
CQuantum.QuantumUnityCallbackDispatcher	Quantum.CallbackDispatcher implementation for Unity. Adds Unity specific callback types. Additional user callback types can be added via partial method
►CQuantum.EventDispatcher	Publish, subscribe pattern for Quantum events: EventBase. Quantum events are used to communicate view relevant game updates from the simulation to the view
CQuantum.QuantumUnityEventDispatcher	Quantum.EventDispatcher implementation for Unity
CQuantum.DispatcherHandlerFlags	Built-in flags for DispatcherBase.Subscribe<TDispatchable>(object, DispatchableHandler<TDispatchable>, bool, uint, DispatchableFilter)
CQuantum.Physics2D.DistanceJoint	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
CQuantum.Physics3D.DistanceJoint3D	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
CQuantum.DotNetSessionContext	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
CQuantum.DotNetSessionRunner	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
CQuantum.Draw	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)
CQuantum.DynamicAssetDB	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
CQuantum.QuantumRunnerLocalDebug.DynamicAssetDBSettings	Settings used to initialize the dynamic db
CQuantum.Shape2D.EdgeShape	Defines a 2D edge in its local space. In order to create a Shape2D of type Shape2DType.Edge, use Shape2D.CreateEdge. See also Shape2D, Shape2DType
CQuantum.EditMeshScope	Scope for editing triangles of a mesh collider
CQuantum.EditorButtonAttribute	Specifies that a method should be displayed as a button in the Unity editor
CQuantum.EditorDefines	Quantum editor defines
CQuantum.EditorRectUtils	Unity custom editor GUI utility functions
CQuantum.Core.FrameBase.EntitiesConfig	Global entities configuration
CQuantum.EntityComponentConfigAttribute	Obsolete attribute, use [CodeGen] instead
CQuantum.EntityComponentPair< T >	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
CQuantum.EntityComponentPointerPair< T >	An entity-component pointer pair. Used when iterating over components
CQuantum.EntityPrototype	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
CQuantum.EntityPrototypeRef	Represents a generalized reference to an entity prototype - either EntityPrototype asset or an entity from Map
CQuantum.EntityRef	Quantum entity reference identifies a unique Entity
CQuantum.QuantumEntityView.EntityUnityEvent	Wrapping UnityEvent(QuantumGame) into a class. Is used by the QuantumEntityView to make create and destroy publish Unity events
CQuantum.QuantumUnityDB.Entry	Internal representation of an asset in the DB. Serialized data remains immutable, while the runtime data is mutable
CQuantum.EnumEqualityComparer	Enum utility methods
CQuantum.ComponentBlockIterator< T >.Enumerator	ComponentBlockIterator enumerator object
CPhoton.Deterministic.FP.EqualityComparer	Equality comparer for FPs
CPhoton.Deterministic.FPVector2.EqualityComparer	Represents an equality comparer for FPVector2 objects
CPhoton.Deterministic.FPVector3.EqualityComparer	Represents an equality comparer for FPVector3 objects
CPhoton.Deterministic.IntVector2.EqualityComparer	Represents an equality comparer for IntVector2 objects
CPhoton.Deterministic.IntVector3.EqualityComparer	Represents an equality comparer for IntVector3 objects
CQuantum.ColorRGBA.EqualityComparer	The equality comparer for ColorRGBA instances
CQuantum.EventList	Internally used class
CQuantum.ExitInfo2D	Info about two entities that were colliding in the 2D Physics
CQuantum.ExitInfo3D	Info about two entities that were colliding in the 3D Physics
►CQuantum.FieldsMask	Base class for FieldsMask<T>
CQuantum.FieldsMask< T >	Associates and displays a 64 bit mask which represents the field members of a struct. Makes it possible to treat a Struct like an Flags Enum. NOTE: A FieldsMask<T> attribute is required for proper rendering in the Inspector
CQuantum.Navigation.FindPathResult	The result object for FindPath requests
CQuantum.FixedArray	Provides utility methods for working with Quantum fixed-size arrays
CQuantum.FixedArray< T >	A Quantum array with fixed size
CQuantum.Json.FixedSizeBufferConverter	Converts fixed-size buffers to and from JSON in a way compatible with the Unity's built-in JSON utility
CQuantum.FloatMinMax	A struct that holds min and max float values and comes with a few inspector tools
CQuantum.FormerlySerializedAsAttribute	A replacement for UnityEngine.Serialization.FormerlySerializedAsAttribute
CPhoton.Deterministic.FP	A fixed-point number. 16 lower bits are used for the decimal part, 48 for the integral part
CQuantum.FPAnimationCurve	A deterministic discretized animation curve. Values between keyframes are interpolated linearly
CPhoton.Deterministic.FPBounds2	Represents an 2D axis aligned bounding box (AABB)
CPhoton.Deterministic.FPBounds3	Represents an 3D axis aligned bounding box (AABB)
CPhoton.Deterministic.FPCollision	A collection of collision helper functions
CPhoton.Deterministic.FPHighPrecisionDivisor	Represents a high precision divisor for use with the Fixed Point math system
CPhoton.Deterministic.FPLut	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
CPhoton.Deterministic.FPMath	A collection of common math functions
CQuantum.FPMathUtils	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
CPhoton.Deterministic.FPMatrix2x2	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>)
CPhoton.Deterministic.FPMatrix3x3	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]
CPhoton.Deterministic.FPMatrix4x4	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]
CPhoton.Deterministic.FPQuaternion	A Quaternion representing an orientation
CPhoton.Deterministic.FPVector2	Represents a 2D Vector
CPhoton.Deterministic.FPVector3	Represents a 3D Vector
CQuantum.Frame	The user implementation of FrameBase that resides in the project quantum_state and has access to all user relevant classes
CQuantum.Core.FrameBase	The Frame class is the container for all the transient and static game state data, including the API for entities, physics, assets and others
CQuantum.Core.FrameBase.FrameBaseUnsafe	Frame API to give access to C# unsafe pointers and advanced immediate operations
CQuantum.FrameChecksumerBitStream	Represents a bit stream used for frame checksum calculation. Implements the IBitStream interface
►CQuantum.Core.FrameContext	The FrameContext is shared between individual transient FrameBase instances
CQuantum.FrameContextUser	Use this class to extend the Core.FrameContext class
CQuantum.QuantumGame.FramesContainer	Stores the different frames the simulation uses during one tick
CQuantum.Frame.FrameSignals	The Quantum signal API consist of core and user-defined code-generated signals
CQuantum.FrameThreadSafeExtensions	Extension methods for the FrameThreadSafe class
CQuantum.FrameTimer	Built in timer used for timing game logic
CQuantum.GameObjectUtils	Unity game object utility methods for Quantum
CQuantum.GizmoIconColorAttribute	Defines the color of a gizmo header in the overlay
CQuantum.GizmoUtils	Utility class for drawing gizmos
CQuantum.GlobalsCore	Internally used class
CQuantum.Editor.QuantumEditorShortcutsWindow.GridScope	A grid scope for the Quantum global config window
CQuantum.DispatcherBase.HandlerDisposable	A helper class that allows to create a subscription that is active until the caller disposes the result
CQuantum.HashCodeUtils	Hashcode generation utilities
CQuantum.Allocator.HeapAllocationTrackerExt	Extension methods for the IHeapAllocationTracker
CQuantum.Physics2D.HingeJoint	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
CQuantum.Physics3D.HingeJoint3D	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
CQuantum.Physics2D.Hit	Information returned from a valid hit of a physics query
CQuantum.Physics3D.Hit3D	Information returned from a valid hit of a physics query
CQuantum.Physics2D.HitCollection	Collection of hits returned from a physics query
CQuantum.Physics3D.HitCollection3D	Collection of hit information returned from a physics query
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
►CQuantum.IAssetSerializer	Represents a serializer that handles assets and various configuration objects
CQuantum.QuantumUnityJsonSerializer	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
CQuantum.IAssetSerializerExtensions	An extension class for IAssetSerializer
►CQuantum.ICallbackDispatcher	A callback dispatcher interface. Implementations of this interface are responsible for dispatching callbacks to the runtime
CQuantum.CallbackDispatcher	A subscribe and publish pattern for Quantum callbacks. A Quantum callback is a invocation from inside the simulation during certain situations
►CQuantum.ICallbackUnityScene	An interface for callbacks that are related to Unity scenes
CQuantum.CallbackUnitySceneLoadBegin	Callback sent when a Unity scene load begins. To enable this feature SimulationConfig.AutoLoadSceneFromMap must be toggled on
CQuantum.CallbackUnitySceneLoadDone	Callback sent when a Unity scene load is done
CQuantum.CallbackUnitySceneUnloadBegin	Callback sent when a Unity scene unload begins
CQuantum.CallbackUnitySceneUnloadDone	Callback sent when a Unity scene unload is done
►CQuantum.Core.ICollisionCallbacks2D	Interface for receiving 2D collision callbacks
CQuantum.Core.PhysicsSystem2D	The Quantum core physics system
►CQuantum.Core.ICollisionCallbacks3D	Interface for receiving 3D collision callbacks
CQuantum.Core.PhysicsSystem3D	The Quantum 3D physics system
►CQuantum.IComponent	The interface to identify Quantum components
CQuantum.CharacterController2D	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
CQuantum.CharacterController3D	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
CQuantum.IComponentSingleton	The interface to identify Quantum singleton components
CQuantum.MapEntityLink	Map entity link can be used inside a component to reference an entity from the map
CQuantum.NavMeshAvoidanceAgent	A component that will make the agent avoid other agents while calculating the navigation steering. Requires NavMeshSteeringAgent and NavMeshPathfinder
CQuantum.NavMeshAvoidanceObstacle	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
CQuantum.NavMeshPathfinder	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
CQuantum.NavMeshSteeringAgent	A component to enable the steering toward a target position calculated by the navigation system. Requires NavMeshPathfinder component
CQuantum.PhysicsBody2D	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
CQuantum.PhysicsBody3D	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
CQuantum.PhysicsCallbacks2D	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
CQuantum.PhysicsCallbacks3D
CQuantum.PhysicsCollider2D	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
CQuantum.PhysicsCollider3D	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
CQuantum.PhysicsJoints2D	A component holding one or more Physics2D.Joint, defining connections between a 2D Physics Body and anchors according to velocity and/or position constraints
CQuantum.PhysicsJoints3D	A component holding one or more Joint3D, defining connections between a 3D Physics Body and anchors according to velocity and/or position constraints
CQuantum.Transform2D	The Transform2D is an entity component providing position and rotation a 2D object
CQuantum.Transform2DVertical	The Transform2DVertical is an entity component pseudo-3D height and offset for an entity
CQuantum.Transform3D	The Transform3D is an entity component providing position and rotation for a 3D object
CQuantum.View	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
CQuantum.Core.IDerivedStruct< T >	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
►CPhoton.Deterministic.IDeterministicCommandFactory	The command factor interface
►CPhoton.Deterministic.DeterministicCommand	The base class for deterministic commands. Always override Serialize(BitStream) to add additional data
CQuantum.Core.CompoundCommand	An auxiliary command that can be used to send multiple commands in one. Nested compound commands are accepted
CPhoton.Deterministic.DeterministicCommandPool< T >	Create a deterministic command pool for a specific command type. Make sure to reset all command data when reusing the objects
►CPhoton.Deterministic.IDeterministicCommandPool	Command pool interface
CPhoton.Deterministic.DeterministicCommandPool< T >	Create a deterministic command pool for a specific command type. Make sure to reset all command data when reusing the objects
CPhoton.Deterministic.IDeterministicDeltaCompressedInput	The interface encapsulates managing the access to delta compressed input
CPhoton.Deterministic.IDeterministicFrameSerializer	The interface of the serializer object used to serialize and deserialize components
►CPhoton.Deterministic.IDeterministicGame	The deterministic game interface is the main hub that holds information about the simulation on the Quantum.Deterministic level
CQuantum.QuantumGame	QuantumGame acts as an interface to the simulation from the client code's perspective
►CPhoton.Deterministic.IDeterministicInputProvider	The interface encapsulates managing the Quantum input
►CPhoton.Deterministic.IDeterministicReplayProvider	An internal interface to encapsulate managing rpc and input
►CPhoton.Deterministic.IDeterministicStreamReplayInputProvider	The interface to implement streaming input for a Quantum replay session
CQuantum.BitStreamReplayInputProvider	This implementation of IDeterministicStreamReplayInputProvider is used to provide delta compressed input for a Quantum simulation replay from a BitStream
CQuantum.StreamReplayInputProvider	The stream replay input provider is used to play back input from a stream
CQuantum.InputProvider	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
CQuantum.RingBufferInputProvider	This input provider can store a certain amount of input sets in a ring buffer
►CPhoton.Deterministic.IDeterministicPlatformTaskRunner	The interface for the task runner used in the Quantum task system
CQuantum.DotNetTaskRunner	The implementation of IDeterministicPlatformTaskRunner for .Net frameworks. Not used when running the simulation in Unity
CQuantum.InactiveTaskRunner	An implementation of IDeterministicPlatformTaskRunner that forces the Quantum task system to run synchronously (single-threaded)
►CPhoton.Deterministic.IDeterministicRpcProvider	The interface encapsulates managing the Quantum RPCs
CPhoton.Deterministic.IDeterministicReplayProvider	An internal interface to encapsulate managing rpc and input
►CQuantum.IDispatchable	The interface for the dispatchable callbacks or events
►CQuantum.CallbackBase	The base class for callbacks adds an id to the callback
►CQuantum.QuantumGame.CallbackBase	The base class of Quantum callbacks
CQuantum.CallbackChecksumComputed	Callback called when a checksum has been computed
CQuantum.CallbackChecksumError	Callback called on a checksum error
CQuantum.CallbackChecksumErrorFrameDump	Callback called a frame dump is received due to a checksum error
CQuantum.CallbackEventCanceled	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
CQuantum.CallbackEventConfirmed	Callback called when an event was confirmed by a verified frame
CQuantum.CallbackGameDestroyed	Callback called when the game was destroyed
CQuantum.CallbackGameInit	Callback called when the game is about to start
CQuantum.CallbackGameResynced	Callback called when the game has been re-synchronized from a snapshot and is about to start. Will be followed by the CallbackGameStarted callback."/>
CQuantum.CallbackGameStarted	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
CQuantum.CallbackInputConfirmed	Callback when input was confirmed
CQuantum.CallbackLocalPlayerAddConfirmed	Callback when a local player was successfully added to the game
CQuantum.CallbackLocalPlayerAddFailed	Callback when a adding a local player failed
CQuantum.CallbackLocalPlayerRemoveConfirmed	Callback when a local player was successfully removed from the game
CQuantum.CallbackLocalPlayerRemoveFailed	Callback when removing a local player failed
CQuantum.CallbackPluginDisconnect	Callback called when the local client is disconnected by the plugin
CQuantum.CallbackPollInput	Callback called when the simulation queries local input
CQuantum.CallbackSimulateFinished	Callback called when frame simulation has completed
CQuantum.CallbackTaskProfilerReportGenerated	Callback when ProfilerContextData has been generated
CQuantum.CallbackUnitySceneLoadBegin	Callback sent when a Unity scene load begins. To enable this feature SimulationConfig.AutoLoadSceneFromMap must be toggled on
CQuantum.CallbackUnitySceneLoadDone	Callback sent when a Unity scene load is done
CQuantum.CallbackUnitySceneUnloadBegin	Callback sent when a Unity scene unload begins
CQuantum.CallbackUnitySceneUnloadDone	Callback sent when a Unity scene unload is done
CQuantum.CallbackUpdateView	Callback guaranteed to be called every rendered frame
►CQuantum.EventBase	The base class for Quantum events. Events are a fire-and-forget mechanism to transfer information from the simulation to the view
CQuantum.EventGameResult	Does not have to implement checksum, because it's a hard-coded synced event
CQuantum.IEntityPrototypeMaterializedListener	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
►CQuantum.IEventDispatcher	An event dispatcher interface. Implementations of this interface are responsible for dispatching events to the runtime
CQuantum.EventDispatcher	Publish, subscribe pattern for Quantum events: EventBase. Quantum events are used to communicate view relevant game updates from the simulation to the view
►CQuantum.Allocator.IFrameHeap	Custom heap interface for allocating memory on the frame
CQuantum.Allocator.FrameHeap	Managed frame heap type that wraps a unmanaged Heap instance
►CQuantum.Allocator.ITrackableFrameHeap	Adds memory allocation tracking to the IFrameHeap
CQuantum.Allocator.Heap	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
►CIGameResult	Represents the result of a game
CQuantum.GameResult	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
CIgnoreInAssetObjectCheckAttribute	Helper attribute used in Quantum migration
►CQuantum.Allocator.IHeapAllocationTracker	Interface of the heap allocation tracker
CQuantum.Allocator.SimpleHeapAllocTracker	An allocation tracker for the frame Heap. This implemention is used when HeapTrackingMode.DetectLeaks mode is selected
CQuantum.Allocator.TracedHeapAllocTracker	An allocation tracker for the frame Heap. This implementation is used when HeapTrackingMode.TraceAllocations mode is selected
CIHostProfiler	Interface for the host profiler
CQuantum.IKCCCallbacks2D	The interface receives the interaction callbacks from the character controller system
CQuantum.IKCCCallbacks3D	The interface receives the interaction callbacks from the character controller system
►CQuantum.ILogger	Represents a logger
►CQuantum.TextWriterLogger	Not used anymore
CQuantum.ConsoleLogger	Not used anymore
►CQuantum.ILogSource	An interface for log sources. Implement this interface to be able to pass a custom context to Log methods
►CQuantum.AssetObject	A base class for all Quantum asset objects
CQuantum.SimulationConfig	The SimulationConfig holds parameters used in the ECS layer and inside core systems like physics and navigation
CQuantum.SystemsConfig	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)
CQuantum.QuantumNavMesh.ImportSettings	The Unity navmesh import settings
►CQuantum.INavigationCallbacks	Basic callbacks from the navigation system to Quantum systems
CQuantum.Core.NavigationSystem	The Quantum core navigation system
CQuantum.QuantumRunnerLocalDebug.DynamicAssetDBSettings.InitialDynamicAssetsRequestedUnityEvent	A unity event passing the dynamic asset db
CQuantum.QuantumEntityPrototype.InitialNavMeshTargetInfo	The initial navmesh target info
CQuantum.InputProviderExtensions	Input provider extension methods
CPhoton.Deterministic.InputSetMask	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
CQuantum.InstantReplaySettings	Settings required to record frame snapshots for instant replays
CQuantum.QuantumSnapshotInterpolationTimer.InterpolationBuffer< T >	Simple ring buffer to store transform data
CPhoton.Deterministic.IntVector2	Represents a two-dimensional vector with integer components
CPhoton.Deterministic.IntVector3	Represents a three-dimensional vector with integer components
►CQuantum.Navigation.IPathFinderData	An interface to access a few selected internal pathfinding data
CQuantum.Navigation.PathFinder	Navmesh TA* pathfinder class
►CQuantum.MemoryLayoutVerifier.IPlatform	Represents a platform that can resolve the memory layout of types and detect any potential issues
CQuantum.MemoryLayoutVerifier.DefaultPlatform	The default platform implementation
►CQuantum.IProgressBar	A progress bar that reports back during navmesh baking
CQuantum.NavMeshBakerBenchmarkerProgressBar	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
►CQuantum.IPrototype	A prototype interface. Indicates that the implementing type is a prototype of some kind
CQuantum.DictionaryEntryPrototype	Obsolete class
►CQuantum.StructPrototype	Base class for DSL code-generated structs. The fields will be ordered in alphabetical order when the struct is generated
CQuantum.Prototypes.DistanceJoint3DConfig	Defines a prototype of a Joint3D struct of type JointType3D.DistanceJoint
CQuantum.Prototypes.DistanceJointConfig	Defines a prototype of a Joint struct of type JointType.DistanceJoint
CQuantum.Prototypes.FrameTimerPrototype	Prototype to create a FrameTimer component
CQuantum.Prototypes.HingeJoint3DConfig	Defines a prototype of a Joint3D struct of type JointType3D.HingeJoint
CQuantum.Prototypes.HingeJointConfig	Defines a prototype of a Joint struct of type JointType.HingeJoint
CQuantum.Prototypes.Joint2DConfig	Defines a prototype of a Joint struct of any type
CQuantum.Prototypes.Joint3DConfig	Defines a prototype of a Joint3D struct of any type
CQuantum.Prototypes.SpringJoint3DConfig	Defines a prototype of a Joint3D struct of type JointType3D.SpringJoint
CQuantum.Prototypes.SpringJointConfig	Defines a prototype of a Joint struct of type JointType.SpringJoint
CQuantum.UnionPrototype	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
CQuantum.IQString	QString interface for UTF-16 strings
CQuantum.IQStringUtf8	QString interface for UTF-8 strings
►CQuantum.Editor.IQuantumAssetSourceFactory	A factory that creates IQuantumAssetSource instances for a given asset
CQuantum.Editor.QuantumAssetSourceFactoryResource	A IQuantumAssetSourceFactory implementation that creates QuantumAssetSourceResource<TAsset> instances for assets in the Resources folder
CQuantum.Editor.QuantumAssetSourceFactoryStatic	A IQuantumAssetSourceFactory implementation that creates QuantumAssetSourceStaticLazy<TAsset>
►CQuantum.IQuantumEntityViewPool	Interface to create custom implementation of the entity view pool that can be assigned to the QuantumEntityViewUpdater.Pool
CQuantum.QuantumEntityViewPool	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
►CQuantum.IQuantumUnityDispatcher	An interface marking a dispatcher as being a Quantum Unity dispatcher
CQuantum.QuantumUnityCallbackDispatcher	Quantum.CallbackDispatcher implementation for Unity. Adds Unity specific callback types. Additional user callback types can be added via partial method
CQuantum.QuantumUnityEventDispatcher	Quantum.EventDispatcher implementation for Unity
CQuantum.IQuantumUnityDispatcherExtensions	Set of extension methods for IQuantumUnityDispatcher
►CQuantum.IQuantumViewComponent	The interface that the QuantumEntityViewUpdater uses to control the view components (QuantumViewComponent<T>)
►CQuantum.QuantumViewComponent< T >	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
CQuantum.QuantumEntityViewComponent< T >	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
CQuantum.QuantumSceneViewComponent< T >	The SceneViewComponent is able to attach itself to the QuantumEntityViewUpdater and received updates from it
CQuantum.IQuantumViewContext	Use this interface to create view context classes that can be used inside concrete QuantumEntityViewComponent<T>
►CQuantum.IResourceManager	Represents an asset manager that can load, unload, and dispose AssetObject
CQuantum.QuantumUnityDB	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)
CQuantum.ResourceManagerStatic	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
CQuantum.IResourceManagerExtensions	Extension methods for IResourceManager
►CQuantum.IRunnerFactory	The interface for the runner factory. It creates platform specific objects to run the Quantum simulation
CQuantum.DotNetRunnerFactory	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
CQuantum.QuantumRunnerUnityFactory	Implements the runner factory to Unity platform
►CIRuntimeConfig	Represents the runtime configuration for the Quantum engine
CQuantum.RuntimeConfig	In contrast to the SimulationConfig, which has only static configuration data, the RuntimeConfig holds information that can be different from game to game
CIRuntimePlayer	Represents a runtime player
►CISerializationCallbackReceiver	A replacement for UnityEngine.ISerializationCallbackReceiver
CQuantum.QuantumFrameDifferGUI.FrameDifferState	The state saves multiple frame dumps
CQuantum.QUnityComponentPrototypeRef< T >	Obsolete, still defined to prevent data loss
►CQuantum.ISignal	Represents a signal. Not meant to be implemented directly
CQuantum.ISignalOnCollision2D	Interface for receiving callbacks once per frame while two non-trigger 2D colliders are touching
CQuantum.ISignalOnCollision3D	Interface for receiving callbacks once per frame while two non-trigger 3D colliders are touching
CQuantum.ISignalOnCollisionEnter2D	Interface for receiving callbacks once two non-trigger 2D colliders start touching
CQuantum.ISignalOnCollisionEnter3D	Interface for receiving callbacks once two non-trigger 3D colliders start touching
CQuantum.ISignalOnCollisionExit2D	Interface for receiving callbacks once two non-trigger 2D colliders stop touching
CQuantum.ISignalOnCollisionExit3D	Interface for receiving callbacks once two non-trigger 3D colliders stop touching
CQuantum.ISignalOnComponentAdded< T >
CQuantum.ISignalOnComponentRemoved< T >
CQuantum.ISignalOnEntityPrototypeMaterialized
►CQuantum.ISignalOnMapChanged
CQuantum.Core.EntityPrototypeSystem	The Quantum core system that creates map entities from the map prototype. Switching maps will destroy all entities and create new ones
CQuantum.ISignalOnNavMeshMoveAgent
CQuantum.ISignalOnNavMeshSearchFailed
CQuantum.ISignalOnNavMeshWaypointReached
CQuantum.ISignalOnPlayerAdded
CQuantum.ISignalOnPlayerConnected
CQuantum.ISignalOnPlayerDataSet	Obsolete: use ISignalOnPlayerAdded
CQuantum.ISignalOnPlayerDisconnected
CQuantum.ISignalOnPlayerRemoved	/>
CQuantum.ISignalOnTrigger2D	Interface for receiving callbacks once per frame while a non-trigger and a trigger 2D colliders are touching
CQuantum.ISignalOnTrigger3D	Interface for receiving callbacks once per frame while a non-trigger and a trigger 3D colliders are touching
CQuantum.ISignalOnTriggerEnter2D	Interface for receiving callbacks once a non-trigger and a trigger 2D colliders start touching
CQuantum.ISignalOnTriggerEnter3D	Interface for receiving callbacks once a non-trigger and a trigger 3D colliders start touching
CQuantum.ISignalOnTriggerExit2D	Interface for receiving callbacks once a non-trigger and a trigger 2D colliders stop touching
CQuantum.ISignalOnTriggerExit3D	Interface for receiving callbacks once a non-trigger and a trigger 3D colliders stop touching
CQuantum.ISignalOnComponentAdded< AddComponentTimer >
CQuantum.ISignalOnComponentAdded< FixedPosition >
CQuantum.ISignalOnComponentAdded< InitialVelocity2D >
CQuantum.ISignalOnComponentAdded< InitialVelocity3D >
CQuantum.ISignalOnComponentRemoved< AddComponentTimer >
CQuantum.Collections.QList< T >.Iterator	An iterator for traversing the entries of a QList<T>. This iterator allows for traversing the entries stored within the list in a sequential manner
CQuantum.Physics2D.Joint	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
CQuantum.Physics3D.Joint3D	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
CQuantum.PhysicsJoints2D.JointsIterator	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
CQuantum.PhysicsJoints3D.JointsIterator3D	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
CQuantum.JsonUtilityExtensions	Extends capabilities of JsonUtility by adding type annotations to the serialized JSON, Unity object reference handling and integer enquotement
CQuantum.FPAnimationCurve.Keyframe	Only used to recreate the curve in the Unity Editor
CLastSupportedVersionAttribute	Marks the last Quantum version that supports the attributed type/method/property/field
CQuantum.LayerInfo	Physics layer information
CQuantum.LayerMask	The Quantum physics layer mask used with LayerValue
CQuantum.LayerValue	The Quantum physics layer value used with LayerMask
CQuantum.Log	Quantum's logging system
CQuantum.LogContext	Additional info about the log context
CQuantum.LogLevelExtensions	Extensions for LogLevel
CQuantum.LogSettings	Settings for the logging system
►CQuantum.LogStream	Interface for logging streams
►CQuantum.TextWriterLogStream	A log stream that writes log messages to a TextWriter
CQuantum.ConsoleLogStream	A log stream that writes log messages to the console with a specified color
CQuantum.MailboxSet8	A utility class to optimize periodic checks by saving a iteration value for each index of the initial capacity
►CQuantum.Map	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
CQuantum.DynamicMap	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
CQuantum.MapDataBakerCallback	Derive from the class to receive callbacks during Quantum map baking. Add the QuantumMapBakeAssemblyAttribute assembly attribute when the implementation is located in different assemblies
CQuantum.MapDataBakerCallbackAttribute	Add this attribute to implementations of MapDataBakerCallback to control the order in which the callbacks are finally executed. Works across different assemblies
CQuantum.MapEntityId	Represents a Quantum entity that is part of a map
CQuantum.MapStaticCollider2D	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
CQuantum.MapStaticCollider2DPolygonData	Stores 2D polygon collider data used on static collider MapStaticCollider2D
CQuantum.MapStaticCollider3D	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
CQuantum.Mask256	Mask256 is a 256-bit mask that can be used to store 256 boolean values
CQuantum.MemoryLayoutVerifier	Verifies the memory layout of types and detects any potential issues
CQuantum.Shape3D.MeshShape	References a static Mesh collider by its index
CQuantum.MeshUnmanagedTrianglesRef	A lightweight reference to a mesh in unmanaged memory
►CPhoton.Deterministic.Protocol.Message	The base class for Quantum network messages
CPhoton.Deterministic.Protocol.AddPlayer	This messages is send from the client to reserve a player slot
CPhoton.Deterministic.Protocol.AddPlayerFailed	This message is sent from the server when the AddPlayer request failed
CPhoton.Deterministic.Protocol.ClockCorrect	Obsolete protocol message
CPhoton.Deterministic.Protocol.Command	Creates a Quantum command
CPhoton.Deterministic.Protocol.Disconnect	Is sent from the server to gracefully disconnect a client
CPhoton.Deterministic.Protocol.FrameSnapshot	The client sends a snapshot of the game state to the server. The message is send multiple times if the snapshot is too large
CPhoton.Deterministic.Protocol.FrameSnapshotRequest	The server request a frame snapshot from the client
CPhoton.Deterministic.Protocol.GameResult	The client sends this message to report the game result
CPhoton.Deterministic.Protocol.RemovePlayer	The client requests to remove a player from the simulation
CPhoton.Deterministic.Protocol.RemovePlayerFailed	The server reponds to RemovePlayer with this message if the player could not be removed
CPhoton.Deterministic.Protocol.RttUpdate	This message is sent frequently from the client to the server to synchronize the distributed systems
CPhoton.Deterministic.Protocol.SimulationStart	The server sends the start signal
CPhoton.Deterministic.Protocol.SimulationStop	The simulation stopped message. Is not used yet
CPhoton.Deterministic.Protocol.StartRequest	The client request to start a online simulation session
CPhoton.Deterministic.Protocol.TickChecksum	This message contains the client game state checksum for a specific tick
CPhoton.Deterministic.Protocol.TickChecksumError	The message is sent from the server to the client when a checksum error is detected
CPhoton.Deterministic.Protocol.TickChecksumErrorFrameDump	The message is sent from the client to the server to distribute the game state to compare on other clients
CQuantum.MovedFromAttribute	A replacement for UnityEngine.Scripting.APIUpdating.MovedFromAttribute
CPhoton.Deterministic.Native	Native is a collections of tools that interact with the platform's native code directly like memory allocation, copy operations, etc
CQuantum.Navigation	Navigation API
CQuantum.NavMesh	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
CQuantum.NavMeshAgentConfig	The configuration file for navmesh agent components
CQuantum.NavMeshAgentSteeringData	Navmesh agent steering data passed into callbacks
CQuantum.QuantumEntityPrototype.NavMeshAvoidanceAgentInfo	Navmesh avoidance agent info
CQuantum.Prototypes.NavMeshAvoidanceAgentPrototype	Prototype of the NavMeshAvoidanceAgent Quantum component
CQuantum.Prototypes.NavMeshAvoidanceObstaclePrototype	Prototype of the NavMeshAvoidanceObstacle Quantum component
CQuantum.NavMeshBakeData	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
CQuantum.NavMeshBakeDataLink	Creates a extra link between two triangles on the navmesh
CQuantum.NavMeshBakeDataTriangle	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
CQuantum.NavMeshBakeDataVertex	Stores a 3D position
CQuantum.NavMeshBaker	The NavMeshBaker turns the intermediate navmesh format NavMeshBakeData into a Quantum NavMesh
CQuantum.NavMeshBorder	The navmesh border data structure
CQuantum.NavMeshBorderNode	The navmesh border node data structure that stores all borders inside a 2D grid for global raycasts for example
CQuantum.NavMeshLink	The navmesh link data structure
CQuantum.QuantumEntityPrototype.NavMeshPathfinderInfo	The navmesh pathfinder info
CQuantum.Prototypes.NavMeshPathfinderPrototype	Prototype of the NavMeshPathfinder Quantum component
CQuantum.NavMeshPortal	The Quantum navmesh stores connections between neighbouring triangles as portals
CQuantum.NavMeshRegionMask	Internally stores a unsigned long to be able to toggle 128 different regions
CQuantum.QuantumEntityPrototype.NavMeshSpec	Navmesh specification for prototypes
CQuantum.QuantumEntityPrototype.NavMeshSteeringAgentInfo	Navmesh steering agent info
CQuantum.Prototypes.NavMeshSteeringAgentPrototype	Prototype of the NavMeshSteeringAgent Quantum component
CQuantum.NavMeshTriangle	The navmesh triangle data structure
CQuantum.NavMeshTriangleCenterGridNode	This grid stores one fallback triangle per cell
CQuantum.NavMeshTriangleNode	A grid or all triangles used for quick lookups
CQuantum.NavMeshVertex	The navmesh vertex data structure is saves as an array in the NavMesh.Vertices
CPhoton.Deterministic.NullableFP	A serializable equivalent of Nullable<FP>
CPhoton.Deterministic.NullableFPVector2	A serializable equivalent of Nullable<FPVector2>
CPhoton.Deterministic.NullableFPVector3	A serializable equivalent of Nullable<FPVector3>
CPhoton.Deterministic.NullableNonNegativeFP	A serializable equivalent of Nullable<FP>
CQuantum.OptionalGizmoBool	Allows optional gizmo values to be serialized in the inspector
CQuantum.QuantumEntityPrototype.OverrideFP	Data object to store a bool and a fixed point to represent overriding default values
CQuantum.PathUtils	Utility methods to work with folder and file paths
CQuantum.Navigation.PathVertex	The data structure for the internal path waypoints
CQuantum.Core.DebugCommand.Payload	The debug command payload
CQuantum.Prototypes.PhysicsBody2DPrototype	Prototype of the PhysicsBody2D Quantum component
CQuantum.Prototypes.PhysicsBody3DPrototype	Prototype of the PhysicsBody3D Quantum component
CQuantum.QuantumEntityPrototype.PhysicsBodyGeneric	The all-purpose physics body info
CQuantum.Prototypes.PhysicsCallbacks2DPrototype	Prototype of the PhysicsCallbacks2D Quantum component
CQuantum.Prototypes.PhysicsCallbacks3DPrototype	Prototype of the PhysicsCallbacks3D Quantum component
CQuantum.Prototypes.PhysicsCollider2DPrototype	Prototype of the PhysicsCollider2D Quantum component
CQuantum.Prototypes.PhysicsCollider3DPrototype	Prototype of the PhysicsCollider3D Quantum component
CQuantum.QuantumEntityPrototype.PhysicsColliderGeneric	A all-purpose physics collider info
CQuantum.Physics2D.PhysicsEngine2D	2D Physics API
CQuantum.Physics3D.PhysicsEngine3D	3D Physics API
CQuantum.Prototypes.PhysicsJoints2DPrototype	Prototype of the PhysicsJoints2D Quantum component
CQuantum.Prototypes.PhysicsJoints3DPrototype	Prototype of the PhysicsJoints3D Quantum component
CQuantum.PhysicsMaterial	The Quantum's asset with the definitions for a PhysicsMaterialData
CQuantum.PhysicsMaterialData	Defines the settings for a physics body to resolve its collision when it is touching another body
CPhoton.Deterministic.Plane	Represents a plane in three-dimensional space
CQuantum.PlayerRef	Represents a Quantum player
CQuantum.PolygonCollider	The asset that contains data of a convex polygon
CQuantum.PolygonColliderRuntimeData	The buffers with runtime data for the vertices and normals. They are loaded when the asset is added or replaced
CQuantum.Shape2D.PolygonShape	References a Polygin shape by the AssetRef<T> of its Quantum.PolygonCollider asset
CPhoton.Deterministic.DeterministicTickInput.Pool	The input objects are pooled
CQuantum.PreserveAttribute	A replacement for UnityEngine.Scripting.PreserveAttribute
CQuantum.Profiling.Profiler	Represents a profiler that can be used for performance profiling
CQuantum.Profiling.ProfilerContext	Represents a profiler context that manages profiling data
CQuantum.Profiling.ProfilerContextData	Represents the data collected by the profiler for all the threads for a single frame
CQuantum.Profiling.ProfilerData	Data collected by the profiler
CQuantum.Profiling.Profiler.ProfilerScope	Represents a disposable profiler scope that automatically starts and ends a profiling section
CQuantum.ProgressBar	A progress bar implementation used by the navmesh importing. The progress bar is only showed when the LogLevel is set to Debug
►CQuantum.PropertyAttribute	A replacement for UnityEngine.PropertyAttribute
►CQuantum.DecoratingPropertyAttribute	A base class for property attributes that decorate other property attributes
CQuantum.ArrayLengthAttribute	Editor attribute for selecting the minimum and maximum length constraints for an array field
CQuantum.DictionaryAttribute	Represents an attribute that can be applied to a field to indicate that it is a dictionary property
CQuantum.DisplayNameAttribute	Specifies the display name for a field
►CQuantum.DoIfAttributeBase	Editor attribute for selective editor rendering. Condition member can be a property, field or method (with a return value)
CQuantum.DrawIfAttribute	Editor attribute for selectively drawing/hiding fields. Condition member can be a property, field or method (with a return value)
CQuantum.ErrorIfAttribute	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)
CQuantum.WarnIfAttribute	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)
CQuantum.DynamicCollectionAttribute	Marks a collection field as source for a Quantum heap-based collection. Automatically applied by CodeGen
CQuantum.FieldEditorButtonAttribute	Editor attribute to add a button that invokes a custom method in the inspector
CQuantum.HideArrayElementLabelAttribute	Attribute used to hide the label of an array element in the inspector
CQuantum.InlineHelpAttribute	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
CQuantum.OptionalAttribute	Marks a field as optional. In Unity, the path passed will serve as the toggle to enable/disable
CQuantum.ReadOnlyAttribute	Attribute used to mark a field as read-only
CQuantum.SerializeReferenceTypePickerAttribute	Attribute used to show a type picker for a field with [SerializeReference]
CQuantum.UnitAttribute	Unit Attribute class. Used to mark a field with the respective Units
►CQuantum.DrawerPropertyAttribute	A base class for property attributes that are used to draw properties in the inspector
CQuantum.AssemblyNameAttribute	Specifies that the attributed field represents the name of an assembly
CQuantum.BinaryDataAttribute	Specifies that the field represents binary data
CQuantum.BitSetAttribute	Represents an attribute that specifies the number of bits in a bit set
CQuantum.DisplayAsEnumAttribute	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
CQuantum.DrawInlineAttribute	Specifies that a field should be drawn inline in the inspector
CQuantum.ExpandableEnumAttribute	Editor attribute that shows an enum as an expandable list of options in the inspector
CQuantum.LayerAttribute	Specifies that an int field should be drawn as a layer field in the inspector
CQuantum.LayerMatrixAttribute	Specifies that the integer array field should be drawn as a layer matrix in the inspector
CQuantum.MaxStringByteCountAttribute	Specifies that the string field should be drawn as a text field with a maximum byte count for given encoding
CQuantum.RangeExAttribute	Represents an attribute that specifies a range of values for a field or property
CQuantum.ScenePathAttribute	Specifies that a string field represents a scene path
CQuantum.ToggleLeftAttribute	Specifies that the bool field should be drawn as the toggle on the left side of the label
CQuantum.UnityAssetGuidAttribute	Specifies that the string field represents a GUID of an asset
CQuantum.UnityResourcePathAttribute	Specifies that the string field represents a path to a Unity resource
CQuantum.HeaderAttribute	A replacement for UnityEngine.HeaderAttribute
CQuantum.HideInInspectorAttribute	A replacement for UnityEngine.HideInInspector
CQuantum.LocalReferenceAttribute	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
CQuantum.MinMaxSliderAttribute	An attribute to display a slider in the Unity inspector between a min and max value
CQuantum.MultiTypeReferenceAttribute	Adds one object picker per type to the inspector
CQuantum.NonReorderableAttribute	A replacement for UnityEngine.NonReorderableAttribute
CQuantum.RangeAttribute	A replacement for UnityEngine.RangeAttribute
CQuantum.ScriptHelpAttribute	Defines the appearance of the script header in the Unity inspector
CQuantum.SerializableTypeAttribute	Specifies that either a string field represents a type name or sets additional options for SerializableType field
CQuantum.SpaceAttribute	A replacement for UnityEngine.SpaceAttribute
CQuantum.TooltipAttribute	A replacement for UnityEngine.TooltipAttribute
CQuantum.UnityAddressablesRuntimeKeyAttribute	Specifies that the string field represents a key for Unity Addressables
CQuantum.Ptr	The Ptr is a pointer wrapper to a memory location inside the frame heap
CQuantum.QBoolean	Quantum boolean type that is stored on components
CQuantum.Collections.QCollectionsUtils	Helper class with utility methods used by QCollections
CQuantum.Collections.QDictionary	A Quantum dictionary-like collection which uses the frame heap. This collection relies on Frame and on its API for allocating, deallocating and resolving
CQuantum.Collections.QDictionary< K, V >	A Quantum dictionary-like collection which uses the frame heap. This collection relies on Frame and on its API for allocating, deallocating and resolving
CQuantum.Collections.QDictionaryIterator< K, V >	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
CQuantum.Collections.QDictionaryPtr< K, V >	Stores a Quantum.Ptr which points to the memory location of a QDictionary<K, V> inside the frame heap
CQuantum.QEnum16< T >	A variable sized enum field backed by a short value. The type helps with consistency and backwards compatibility when Enum types change during development
CQuantum.QEnum16< QueryOptions >
CQuantum.QEnum32< T >	A variable sized enum field backed by a int value. The type helps with consistency and backwards compatibility when Enum types change during development
CQuantum.QEnum32< CallbackFlags >
CQuantum.QEnum32< QueryOptions >
CQuantum.QEnum64< T >	A variable sized enum field backed by a long value. The type helps with consistency and backwards compatibility when Enum types change during development
CQuantum.QEnum8< T >	A variable sized enum field backed by a sbyte value. The type helps with consistency and backwards compatibility when Enum types change during development
CQuantum.QEnum8< Quantum.Quantum.PhysicsBody2D.ConfigFlags >
CQuantum.QEnum8< Quantum.Quantum.PhysicsBody3D.ConfigFlags >
CQuantum.QEnum8< RotationFreezeFlags >
CQuantum.Collections.QEnumDictionary< K, V >	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
CQuantum.Collections.QHashSet< T >	A Quantum hashset-like collection which uses the frame heap. This collection relies on Frame and on its API for allocating, deallocating and resolving
CQuantum.Collections.QHashSetIterator< T >	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
CQuantum.Collections.QHashSetPtr< T >	Stores a Quantum.Ptr which points to the memory location of a QHashSet<T> inside the frame heap
CQuantum.Collections.QList< T >	A Quantum list-like collection which uses the frame heap. This collection relies on Frame and on its API for allocating, deallocating and resolving
CQuantum.Collections.QList	A Quantum list-like collection which uses the frame heap. This collection relies on Frame and on its API for allocating, deallocating and resolving
CQuantum.Collections.QListPtr< T >	Stores a Quantum.Ptr which points to the memory location of a QList<T> inside the frame heap
CQuantum.QString	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
CQuantum.QStringUtf8	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
CQuantum.Editor.QuantumAssetSourceFactoryContext	A context object that is passed to IQuantumAssetSourceFactory instances to create an IQuantumAssetSource instance
CQuantum.QuantumAssetSourceResource< T >	Resources-based implementation of the asset source pattern
CQuantum.QuantumAssetSourceResource< Quantum.AssetObject >
CQuantum.QuantumAssetSourceStatic< T >	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
CQuantum.QuantumAssetSourceStatic< Quantum.AssetObject >
CQuantum.QuantumAssetSourceStaticLazy< T >	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
CQuantum.QuantumAssetSourceStaticLazy< Quantum.AssetObject >
CQuantum.QuantumCallbackHandler_DebugDraw	A handler object that registers to Quantum callbacks and draws debug shapes issued from the simulation
CQuantum.QuantumCallbackHandler_FrameDiffer	A handler object to subscribe to Quantum callbacks to open the frame dump differ in builds after receiving a checksum error frame dumps
CQuantum.QuantumCallbackHandler_GameResult	A handler object that subscribes to Quantum callbacks to send game results to the server
CQuantum.QuantumCallbackHandler_LegacyQuantumCallback	A handler object that subscribes to Quantum callbacks to call legacy QuantumCallbacks in on Unity game objects
CQuantum.QuantumCallbackHandler_StartRecording	A handler object that subscribes to Quantum callbacks to start recording input and checksums
CQuantum.QuantumCallbackHandler_UnityCallbacks	A handler object that subscribes to Quantum callbacks to handle Unity scene loading and unloading
CQuantum.Editor.QuantumCodeGenQtn	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
CQuantum.Editor.QuantumCodeGenSettings	Settings for the Quantum code generation. Extend this class with a partial implementation to customize the settings
CQuantum.QuantumColor	Quantum default colors
CQuantum.QuantumConsoleRunner	Simple command-line runner for Quantum simulations
CQuantum.QuantumDebugInput	A Unity script that creates empty input for any Quantum game
CQuantum.QuantumDefaultConfigsAssetPostprocessor	A Unity asset post processor that makes use to generate default Quantum configs in the user folder
►CQuantum.Editor.QuantumEditor	Base class for all Photon Common editors. Supports EditorButtonAttribute and ScriptHelpAttribute
CQuantum.Editor.QuantumDotnetBuildSettingsInspector	Inspector code to manage the QuantumDotnetBuildSettings asset in the editor
CQuantum.Editor.QuantumInstantReplayDemoEditor	A custom editor to for the instant replay demo. Displays start and stop buttons
CQuantum.Editor.QuantumEditorColliderConverter	This tool can convert Unity colliders to Quantum colliders
CQuantum.Editor.QuantumEditorFrameDifferWindow	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
CQuantum.Editor.QuantumEditorHubWidgetBase	Structured as such that a subclass has child elements to prevent Unity inspector recursion problems
CQuantum.Editor.QuantumEditorMapGizmoStylePopup	Popup window for the map gizmo style
CQuantum.Editor.QuantumEditorMenuCreateAssets	Create Quantum asset and script files using the context menu
CQuantum.Editor.QuantumEditorMenuCreateScene	Utility methods to create and set up a Quantum Unity scene
CQuantum.Editor.QuantumEditorMenuCustomPlugin	Methods to export Quantum assets and configs
CQuantum.Editor.QuantumEditorMenuDllToggle	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
CQuantum.Editor.QuantumEditorMenuLookUpTables	Quantum Look up table tools
CQuantum.Editor.QuantumEditorMenuProfilers	Utility methods to create and set up a Quantum Unity scene
CQuantum.Editor.QuantumEditorSessionShutdown	An Unity Editor hook to shutdown all Quantum sessions when the editor play mode is stopped
CQuantum.Editor.QuantumEditorShortcutsWindow	A utility window to quickly access Quantum global configs
CQuantum.Editor.QuantumEditorSkin	An editor scriptable object that stores UI skins and different GUIStyle Unity inspectors and custom windows
CQuantum.Editor.QuantumEditorToolbarUtilities	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
CQuantum.Editor.QuantumEditorUserScriptGeneration	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
CQuantum.QuantumFrameDifferGUI	The actual GUI to render the frame dumps differences of multiple dumps send by different clients. Uses Unity Immediate Mode GUI
CQuantum.QuantumGameFlags	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
CQuantum.QuantumGameGizmosSettings	The gizmo settings for the Quantum game
CQuantum.QuantumGameStartParameters	Parameters required to start a Quantum game
CQuantum.QuantumGizmoColors	The default Quantum Gizmo colors
►CQuantum.QuantumGizmoEntry	Individual entry for a specific section of Quantum
CQuantum.JointGizmoEntry	Individual entry for specifically the joint section of the gizmo overlay
CQuantum.NavMeshBorderGizmoEntry	Individual entry for specifically the border of the navmesh section of the gizmo overlay
CQuantum.NavMeshComponentGizmoEntry	Individual entry for specifically the NavMesh component section of the gizmo overlay
CQuantum.NavMeshGizmoEntry	Individual entry for specifically the navmesh section of the gizmo overlay
CQuantum.PhysicsComponentGizmoEntry	Individual entry for specifically the physics section of the gizmo overlay
CQuantum.QuantumUserGizmoEntry	User defined gizmo entry
CQuantum.QuantumGizmoStyle	The style of the gizmo
CQuantum.QuantumGlobalScriptableObject	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
CQuantum.QuantumGlobalScriptableObject< T >
►CQuantum.QuantumGlobalScriptableObject< PhotonServerSettings >
CQuantum.PhotonServerSettings	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
►CQuantum.QuantumGlobalScriptableObject< QuantumDefaultConfigs >
CQuantum.QuantumDefaultConfigs	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
►CQuantum.QuantumGlobalScriptableObject< QuantumDeterministicSessionConfigAsset >
CQuantum.QuantumDeterministicSessionConfigAsset	The asset wraps an instance of DeterministicSessionConfig and makes it globally (in Unity) accessible as a default config
►CQuantum.QuantumGlobalScriptableObject< QuantumDotnetBuildSettings >
CQuantum.Editor.QuantumDotnetBuildSettings	A configuration asset to generate and build the non-Unity Quantum simulation dll
►CQuantum.QuantumGlobalScriptableObject< QuantumDotnetProjectSettings >
CQuantum.Editor.QuantumDotnetProjectSettings	A configuration asset that describes the search paths to create a non-Unity simulation project
►CQuantum.QuantumGlobalScriptableObject< QuantumEditorSettings >
CQuantum.QuantumEditorSettings	Contains global Quantum editor settings
►CQuantum.QuantumGlobalScriptableObject< QuantumMeshCollection >
CQuantum.QuantumMeshCollection	A collection of Unity mesh asset to draw gizmos or scene object
►CQuantum.QuantumGlobalScriptableObject< QuantumUnityDB >
CQuantum.QuantumUnityDB	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)
CQuantum.QuantumGlobalScriptableObjectAttribute	Provides additional information for a global scriptable object
CQuantum.QuantumGlobalScriptableObjectLoadResult	The result of QuantumGlobalScriptableObjectSourceAttribute.Load. Contains the loaded object and an optional unloader delegate
►CQuantum.QuantumGlobalScriptableObjectSourceAttribute	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:
CQuantum.QuantumGlobalScriptableObjectAddressAttribute	If applied at the assembly level, allows QuantumGlobalScriptableObject<T> to be loaded with Addressables
CQuantum.QuantumGlobalScriptableObjectResourceAttribute	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
CQuantum.Editor.QuantumGlobalScriptableObjectUtils	Utility methods for working with QuantumGlobalScriptableObject
CQuantum.Profiling.QuantumGraphPlayerLoopUtility	A system to add profiler callbacks into the Unity player loop
CQuantum.Profiling.QuantumGraphPool< T >	A pool for QuantumGraphTimer objects
CQuantum.Profiling.QuantumGraphProfiler< TGraph >	The base class for all Quantum graph profilers
►CQuantum.Profiling.QuantumGraphProfiler< QuantumGraphSeriesMarker >
►CQuantum.Profiling.QuantumGraphProfilerMarkerSeries	A graph profiler that records a series of markers
CQuantum.Profiling.QuantumGraphProfilerMarkers	A Quantum graph profiler that records custom markers
►CQuantum.Profiling.QuantumGraphProfiler< QuantumGraphSeriesValue >
►CQuantum.Profiling.QuantumGraphProfilerValueSeries	Records a series of values for a graph profiler
CQuantum.Profiling.QuantumGraphProfilerDeltaTime	A graph profiler that records the delta time
CQuantum.Profiling.QuantumGraphProfilerFrameTime	A Quantum graph profiler that records the frame time
CQuantum.Profiling.QuantumGraphProfilerGC	A Quantum graph profiler that records the garbage collection time
CQuantum.Profiling.QuantumGraphProfilerNetworkActivity	A Quantum graph profiler that shows the time delta between the last received packet
CQuantum.Profiling.QuantumGraphProfilerPing	A Quantum graph profiler that shows the RTT to the server
CQuantum.Profiling.QuantumGraphProfilerPredictedFrames	A Quantum graph profiler that shows how far the simulation is in predicting
CQuantum.Profiling.QuantumGraphProfilerRenderTime	A Quantum graph profiler that shows the render time
CQuantum.Profiling.QuantumGraphProfilerSimulationTime	A Quantum graph profiler that shows the simulation time
CQuantum.Profiling.QuantumGraphProfilerUserScripts	A Quantum graph profiler that shows the time spent in Unity scripts
CQuantum.Profiling.QuantumGraphProfilerVerifiedFrames	A Quantum graph profiler that shows how many verified frames have been simulated during the last update
CQuantum.Profiling.QuantumGraphProfilers	The main management class in the Quantum graph profilers
CQuantum.Profiling.QuantumGraphProfilersUtility	A utility class for Quantum graph profilers
CQuantum.Profiling.QuantumGraphProfilingStatistics	A Unity script that renders additional statistics to the graph UI
CQuantum.Profiling.QuantumGraphProfilingTools	A Unity script that renders additional profiling tools to the graph UI
►CQuantum.Profiling.QuantumGraphSeries	A graph series is the base class to render graphs in Unity
CQuantum.Profiling.QuantumGraphSeriesMarker	The rendering of a marker series
CQuantum.Profiling.QuantumGraphSeriesValue	The series value graph is used format, average values add graphical features to the graph rendering
CQuantum.Profiling.QuantumGraphTimer	The Quantum graph timer to measure time with a stopwatch
CQuantum.QuantumInstantReplay	The instant replay feature. It can be used as is or used as a base class for custom instant replay implementations
►CQuantum.QuantumJsonFriendlyDataBlob	Wrapper around storing binary data in JSON to work around the problem that Unity JSON tools only serialize byte arrays verbosely
CQuantum.QuantumInputHistoryData	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
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
CQuantum.QuantumLoadBalancingClient	Obsolete: Not used anymore. Replace by using RealtimeClient directly
CQuantum.QuantumLogInitializer	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
CQuantum.QuantumMapBakeAssemblyAttribute	This assembly attribute needs to be set inside custom assemblies that required static edit mode callbacks from the MapDataBakerCallback class. [assembly: QuantumMapBakeAssembly]
CQuantum.Editor.QuantumMenuConfigEditor	Custom inspector for QuantumMenuSceneInfo
►CQuantum.QuantumMonoBehaviour	Base class for all Quantum MonoBehaviours
CQuantum.Demo.QuantumSimpleConnectionGUI	A Unity script that demonstrates how to connect to a Quantum cloud and start a Quantum game session
CQuantum.QuantumAddRuntimePlayers	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)
CQuantum.QuantumCallbacks	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
CQuantum.QuantumEntityPrototype	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
CQuantum.QuantumEntityView	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
CQuantum.QuantumEntityViewPool	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
CQuantum.QuantumEntityViewUpdater	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
CQuantum.QuantumFrameDiffer	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
CQuantum.QuantumInstantReplayDemo	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
CQuantum.QuantumMapData	Unity component that holds and bakes the map data for a Quantum map from a given scene
CQuantum.QuantumMapLoader	A Unity script that helps with loading Quantum maps and scenes
CQuantum.QuantumMemoryStats	A script that displays memory stats of the Quantum heap
CQuantum.QuantumMultiClientPlayer	This class keeps track of individual Photon connections and Quantum simulations (QuantumRunner)
CQuantum.QuantumMultiClientPlayerView	The multi client UI view of one player
CQuantum.QuantumMultiClientRunner	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:
CQuantum.QuantumNavMeshDebugDrawer	Obsolete script. Navmesh editor gizmos are now rendered with the map
CQuantum.QuantumNavMeshRegion	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
CQuantum.QuantumRunnerBehaviour	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()
CQuantum.QuantumRunnerLocalDebug	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)
CQuantum.QuantumRunnerLocalReplay	An example of how to start a Quantum replay simulation from a replay file
CQuantum.QuantumRunnerLocalSavegame	This script can be used to start a Quantum simulation from a savegame file and is very similar to QuantumRunnerLocalReplay
CQuantum.QuantumStaticBoxCollider2D	The script will create a static 2D Quantum box collider during map baking
CQuantum.QuantumStaticBoxCollider3D	The script will create a static 3D Quantum box collider during map baking
CQuantum.QuantumStaticCapsuleCollider2D	The script will create a static 2D capsule collider during Quantum map baking
CQuantum.QuantumStaticCapsuleCollider3D	The script will create a static 3D capsule collider during Quantum map baking
CQuantum.QuantumStaticCircleCollider2D	The script will create a static 2D circle collider during Quantum map baking
CQuantum.QuantumStaticEdgeCollider2D	The script will create a static 2D edge collider during Quantum map baking
CQuantum.QuantumStaticMeshCollider3D	The script will create a static 3D mesh collider during Quantum map baking
CQuantum.QuantumStaticPolygonCollider2D	The script will create a static 2D polygon collider during Quantum map baking
CQuantum.QuantumStaticSphereCollider3D	The script will create a static sphere collider during Quantum map baking
CQuantum.QuantumStaticTerrainCollider3D	The script will create a static 3D terrain collider during Quantum map baking
CQuantum.QuantumStats	Measures and display basic Quantum statistics on a UI element
CQuantum.QuantumViewComponent< T >	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
CQuantum.QuantumMppm	Support for Multiplayer Play Mode (MPPM). It uses named pipes to communicate between the main Unity instance and virtual instances
CQuantum.QuantumMppmCommand	The base class for all Quantum MPPM commands
CQuantum.QuantumNavMesh	This class is a collection of utility methods to import Unity NavMesh data into Quantum NavMesh data
CQuantum.QuantumNetworkCommunicator	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
CQuantum.QuantumPlayerLoopSystemHandle	Represents a system that has been added to the PlayerLoopSystem
CQuantum.QuantumPlayerLoopSystemUtils	Utility class for manipulating Unity Player Loop System
CQuantum.Editor.QuantumProfilingServer	A dummy implementation of the Quantum profiling server
CQuantum.Editor.QuantumQtnAsset	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
CQuantum.QuantumReconnectInformation	Implements MatchmakingReconnectInformation to save reconnect information to player prefs. This way the app can try to reconnect after app start
►CQuantum.QuantumReplayFile	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
CQuantum.ReplayFile	Obsolete class, use QuantumReplayFile instead
CQuantum.QuantumRunnerRegistry	A registry to keep track of all active Quantum runners
►CQuantum.QuantumScriptableObject	Base class for all Quantum scriptable objects
CQuantum.QuantumGameGizmosSettingsScriptableObject	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
CQuantum.QuantumMenuSceneInfo	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)
CQuantum.QuantumSnapshotInterpolationTimer	Configuration of the snapshot interpolation mode when selected in QuantumEntityView.InterpolationMode
CQuantum.Editor.QuantumStateInspector	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
CQuantum.QuantumSnapshotInterpolationTimer.QuantumTransformData	Data structure to hold transform data on an entity in a buffer
CQuantum.Editor.QuantumUnityDBInspector	An editor class that renders a windows displaying assets from the Quantum DB. Open the windows by using Tools > Quantum > Window > Quantum Unity DB
CQuantum.Editor.QuantumUnityDBUtilities	QuantumUnityDB Editor utilities
CQuantum.QuantumUnityExtensions	Provides backwards compatibility for Unity API
CQuantum.QuantumUnityInputSystemWithLegacyFallback	This script simplifies the transition between the new Unity Input System and the legacy Input Manager
CQuantum.QuantumUnityLogger
CQuantum.QuantumUnityStaticDispatcherAdapter< TDispatcher, TDispatchableBase >	Adapter for static dispatchers in Unity. Provides utility static methods, internal worker that removes dead listeners and means for creating a dispatcher
►CQuantum.QuantumUnityStaticDispatcherAdapter< QuantumUnityCallbackDispatcher, CallbackBase >
CQuantum.QuantumCallback	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
►CQuantum.QuantumUnityStaticDispatcherAdapter< QuantumUnityEventDispatcher, EventBase >
CQuantum.QuantumEvent	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
CQuantum.QUnityComponentPrototypeRef	Obsolete, still defined to prevent data loss
CPhoton.Deterministic.FP.Raw	Holds FP constants in raw (long) form
CPhoton.Deterministic.FPHighPrecisionDivisor.Raw	Holds FPHighPrecisionDivisor constants in raw (long) form
CQuantum.ReflectionUtils	Quantum reflection utilities
CPhoton.Deterministic.Webhooks.ReplayChunkRequest	The json webrequest is send if using ReplayStream.WebhookRequestType.Json. Binary web request holds all meta information in according headers
CQuantum.Core.RingBuffer< T >	Ring buffer collection implementation. Stores Capacity number of values and will overwrite the oldest value when full
CPhoton.Deterministic.RNGSession	PCG32 random generator, 16 bytes in size. http://www.pcg-random.org
CQuantum.Rotation2DAttribute	Marks a FP/NullableFP field as a 2D rotation angle
CQuantum.Profiling.Sample	Represents a sample in the profiler
CQuantum.Editor.SerializableEnterRoomArgs	This class wraps the PhotonRealtime EnterRoomArgs class to make problematic members (Hashtable, TypedLobby restrictions) and its hierarchy XML serializable.
CQuantum.SerializableType< BaseType >	A generic version of SerializableType that can be used to store types that inherit from a specific base type
CQuantum.SerializableType	A System.Type wrapper that can be serialized
CQuantum.SerializableType< Quantum.Quantum.AssetObject >
CQuantum.SerializableType< Quantum.SystemBase >
CQuantum.SerializeField	A replacement for UnityEngine.SerializeField
CPhoton.Deterministic.Protocol.Serializer	The Quantum online protocol serializer
CQuantum.SerializeReference	A replacement for UnityEngine.SerializeReference
CQuantum.SessionRunner	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
CQuantum.SessionRunnerException	Runner specific exceptions
CQuantum.Shape2D	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
CQuantum.Shape2DConfig	The base settings for building a Shape2D
CQuantum.Shape3D	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
CQuantum.Shape3DConfig	The base settings for building a Shape3D
CQuantum.Shape3D.SphereShape	Defines a sphere shape in its local space. In order to create a Shape3D of type Shape3DType.Sphere, use Shape3D.CreateSphere. See also Shape3D, Shape3DType
CQuantum.Physics2D.SpringJoint	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
CQuantum.Physics3D.SpringJoint3D	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
CQuantum.StaticColliderData	Information about a static collider
CQuantum.Statics	Static type registry is completed by code generation
CQuantum.Allocator.Heap.Stats	Statistics of the heap
CQuantum.Core.FrameBase.Stats	Represents the memory statistics for a frame in the Quantum.Core namespace
CQuantum.Core.StreamUtils	Streaming utility methods
CQuantum.Task.SystemArrayComponent< Transform2D >
CQuantum.Task.SystemArrayFilter< ArrayFilterTestSystem.Filter >
►CQuantum.SystemBase	The Quantum system base class
CQuantum.Core.CullingSystem2D	During Predicted frames, culls all cullable entities with Transform2D that are positioned out of the prediction area
CQuantum.Core.CullingSystem3D	During Predicted frames, culls all cullable entities with Transform3D that are positioned out of the prediction area
CQuantum.Core.NavigationSystem	The Quantum core navigation system
CQuantum.Core.PhysicsSystem2D	The Quantum core physics system
CQuantum.Core.PhysicsSystem3D	The Quantum 3D physics system
CQuantum.SystemGroup	The base class for a hierarchy of systems
►CQuantum.SystemMainThread	Most common Quantum system type. Implements a regular Update() with all the usual features
CQuantum.Core.PlayerConnectedSystem	The Quantum core player connected system. It will detect changes in the Photon.Deterministic.DeterministicFrame.GetPlayerInputFlags(PlayerRef) and call ISignalOnPlayerConnected and ISignalOnPlayerDisconnected respectively
CQuantum.SystemMainThreadFilter< T >	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
CQuantum.SystemMainThreadGroup	A Quantum main thread system that has a system hierarchy
►CQuantum.SystemSignalsOnly	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
CQuantum.Core.EntityPrototypeSystem	The Quantum core system that creates map entities from the map prototype. Switching maps will destroy all entities and create new ones
CQuantum.Task.SystemArrayComponent< T >	A multi-threaded system to parallelize updating components
CQuantum.Task.SystemArrayFilter< T >	A multi-threaded system to parallelize updating components
CQuantum.Task.SystemThreadedComponent< T >	A multi-threaded system to parallelize updating components
CQuantum.Task.SystemThreadedFilter< T >
►CQuantum.SystemsConfig.SystemEntryBase	System that will be instantiated on simulation start
CQuantum.SystemsConfig.SubSubSystemEntry	2nd sub level system type
CQuantum.SystemsConfig.SystemEntryBase< T >	To prevent indefinite recursion in Unity serialization system hierarchies are limited to 3 levels
►CQuantum.SystemsConfig.SystemEntryBase< SubSubSystemEntry >
CQuantum.SystemsConfig.SubSystemEntry	1st sub level system type
►CQuantum.SystemsConfig.SystemEntryBase< SubSystemEntry >
CQuantum.SystemsConfig.SystemEntry	Base system type
CQuantum.SystemMainThreadFilter< AddComponentTimerSystem.Filter >
CQuantum.SystemMainThreadFilter< CharacterControllerMovementTestSystem.Filter >
CQuantum.SystemMainThreadFilter< Collider3DReferenceFilter >
CQuantum.SystemMainThreadFilter< ColliderReferenceFilter >
CQuantum.SystemMainThreadFilter< CustomGravityTestSystem.Filter >
CQuantum.SystemMainThreadFilter< DrawCenterOfMassTestSystem.Filter >
CQuantum.SystemMainThreadFilter< PhysicsSetVelocity2DTestSystem.Filter >
CQuantum.SystemMainThreadFilter< PhysicsSetVelocity3DTestSystem.Filter >
CQuantum.Task.SystemThreadedComponent< Transform2D >
CQuantum.Task.SystemThreadedFilter< ThreadedFilterTestSystem.Filter >
CQuantum.EnumEqualityComparer.Tag	An empty struct to mark the type as a tag
CQuantum.Shape3D.TerrainShape	References a static Terrain shape by its Quantum.TerrainCollider asset
CQuantum.Navigation.ThreadLocal	An internal class that stored multi-threading related navigation context
CQuantum.Physics2D.PhysicsEngine2D.Api.ThreadSafeApi	Struct to provide thread-safe access to the physics functions
CQuantum.Physics3D.PhysicsEngine3D.Api.ThreadSafeApi	Struct to provide thread-safe access to the physics functions
CQuantum.Prototypes.Transform2DPrototype	Prototype of the Transform2D Quantum component
CQuantum.QuantumEntityPrototype.Transform2DVerticalInfo	Prototype settings for the Transform2DVertical component
CQuantum.Prototypes.Transform2DVerticalPrototype	Prototype of the Transform2DVertical Quantum component
CQuantum.Prototypes.Transform3DPrototype	Prototype of the Transform3D Quantum component
CQuantum.CollisionInfo3D.TriangleCollisionInfo	Info about the collision with a specific triangle of a mesh
CQuantum.CollisionInfo3D.TriangleCollisionIterator	Data regarding a mesh collision, including all the individual triangles
CQuantum.TriangleMesh	The data representation of all static triangles in the scene
CQuantum.TriangleReference	Represents a reference to a triangle in the triangle mesh
CQuantum.TriggerInfo2D	Info about a collision between a trigger and a non-trigger 2D physics colliders
CQuantum.TriggerInfo3D	Info about a collision between a trigger and a non-trigger 3D physics colliders
CQuantum.ReflectionUtils.TypeHierarchyComparer	Comparer for types for sorting
CQuantum.TypeRegistry	The Quantum type registry
CQuantum.TypeUtils	Type reflection utility methods. Is generally slow
CQuantum.Json.UnityContractResolver	Custom contract resolver for Unity objects. The main purpose is to support Unity's SerializeReference attribute
CQuantum.Json.UnityJsonUtilityConvert	Utility methods to convert JSON data serialized by Unity's built-in JSON utility to .NET objects with Newtonsoft.Json
CQuantum.QuantumEntityView.UpdatePositionParameter	The struct is used to gather all transform and interpolation data to apply new transform data to the entity view. ApplyTransform(ref UpdatePositionParameter)
►CPhoton.Deterministic.Native.Utility	Represents a collection of memory utility functions that interact with the platform's native code directly
CPhoton.Deterministic.Native.LIBCUtility	The libc native memory utility implementation
CPhoton.Deterministic.Native.MSVCRTUtility	The MSVCRT native memory utility implementation
CQuantum.QuantumUnityNativeUtility	The Unity implementation of the Quantum native utility functions
CQuantum.TriangleCCW.VertexHashMapper	Uses a ByteSerializerHashMapper<T> to more efficiently serialize triangles with shared vertices to a ByteStream. How to serialize:
CQuantum.Prototypes.ViewPrototype	Prototype of the View Quantum component