1.0.0-pre.65

[1.0.0-pre.65] - 2023-03-21

Added

• Added support for automatic data mode switching to the Entities Hierarchy window and the Inspector window.
• Added BlobAsset safety check for passing blob assets into methods without using ref.
• Added the LocalTransform.ComputeWorldTransformMatrix() which synchronously computes an entity's world-space transform matrix, in the rare cases where an accurate world transform is needed in simulation code and is otherwise be unavailable.
• Added RefRW<T> SystemAPI.GetComponentRW<T>(Entity,bool)
• Bulk SetComponentEnabled operations on EntityManager: EntityManager.SetComponentEnabled<T>(EntityQuery, bool) and EntityManager.SetComponentEnabled(EntityQuery, ComponentType, bool).
• A Unity.Transforms.Helpers class with assorted transform-related helper functions:
  • A simple float4x4 extension methods for field extraction, such as .Up(), .Forward() and .Translation()
  • Added utilities to apply a transformation matrix to a float3 point or direction, or to a quaternion rotation
  • A method to synchronously compute an entity's world-space transform, .ComputeWorldTransformMatrix()
  • A method to compute the "LookAt" quaternion rotation for a position that would cause its "forward" direction to point towards some target.
• TypeIndex.IsChunkSerializable property has been added to identify if a component type is valid in a chunk that is intended to be serialized. If SerializeUtility.SerializeWorld (such as might be called while exporting a subscene) is used to serialize chunks that contain components whose TypeIndex.IsChunkSerializable returns false, an exception will be thrown telling you why the component type is inappropriate for serialization.
• Added WeakSceneReference Unload(Scene scene) method to unload the scene instance and release its resources.
• Added guidance to GetSingleton error message
• Transform Usage Flags
• Added support for managed (shared) components serialization in DOTS runtime.

Changed

• Moved the tool for adding missing partial keywords to system and job types from Edit > Preferences > Entities into a Roslyn codefix. Your IDE of choice should now be able to fix this for you, and give you a red squiggly line if it's missing.
• IJobEntity no longer gives a compile error if you have a reference type field. This improves iteration time, and has the added benefit that you can now write managed code in an IJobEntity. Simply add a managed component to your IJE's Execute (that forces running without the jobsystem). Your job can now validly use that field. If you try to schedule this job rather than running it on the main thread, you'll correctly get thrown a runtime error for having a reference type in your job.
• Improved performance of IJobEntity generator, speeding up compile times. Attributes like WithAll, WithAny etc. now use syntax information directly. This mean that you can't make your own attribute on an IJobEntity named WithAll WithAny, WithNone, WithDisabled, WithAbsent, WithOptions, or WithChangeFilter.
• Updated Burst dependency version to 1.8.3.
• What was PostTransformScale as a float3x3 is now PostTransformMatrix as a float4x4. This is more general and offers maximum flexibility. You can, for example, use it to scale from a secondary pivot.
• ParentSystem removes the Parent component if said component points to an entity that doesn't exist anymore.
• Refactored how additive scenes are handled within the Runtime Content Manager. A scene is now returned, and that is used as the key to unload. This change required some API changes.
• Changed WeakObjectSceneReference.LoadAsync to return the Scene instance, which should be used to check the loading status and for unloading.
• Changed RuntimeContentManager.UnloadScene method to take the Scene instance as the only parameter.
• The BlobAssetStore used during baking now uses garbage collection instead of an explicit refcount. It is not required anymore to register blobs with authoring GameObjects nor to do explicit cleanup in incremental baking systems.
• Source generators for Systems and Aspects no longer default to outputting generated files in Temp/GeneratedCode/***. To turn it on, add DOTS_OUTPUT_SOURCEGEN_FILES to your Scripting Defines in Player Settings. Turning it on will cost compilation time. (The source generator for IJobEntity already made this change earlier.)
• Moved InternalCompilerInterface, EntityQueryEnumerator (now InternalEntityQueryEnumerator) and some other types and methods to the Unity.Entities.Internal namespace. These types and methods are not intended for use by user code. We would make them internal, but source generators won't work correctly that way unfortunately.

Deprecated

• Deprecated WeakSceneReference Release method. Unload should now be used and the scene instance returned by LoadAsync needs to be passed in as a ref.
• RegisterBindingAttribute(Type runtimeComponent, string runtimeField, bool generated). Vector type fields can now be registered automatically without the generated option.
• SceneSystem.UnloadParameters and the overload of SceneSystem.UnloadScene receiving SceneSystem.UnloadParameters as parameters.
• EntityQuery.SetEnabledBitsOnAllChunks as the only bulk operation on EntityQuery instead of EntityManager. Use the newly added bulk SetComponentEnabled overloads instead.
• WeakSceneReference properties LoadingStatus, SceneResult, SceneFileResult.
• RuntimeContentManager methods GetSceneLoadingStatus, GetSceneFileValue, GetSceneValue

Removed

• ENABLE_TRANSFORM_V1 define and existing transform v1 code. Transform v2 is now the only transform system.
• Tooling to re-write user files to add missing partial keywords to systems.
• The TransformAspect struct was removed. Recent changes to the Entities transform systems made the current implementation of TransformAspect much less useful, and we've decided to remove it from the package until we can provide a more valuable abstraction over the DOTS transform components.
• The EntityQueryEnumerator.EntityCount field has been removed from the public API. Note that EntityQueryEnumerator is only intended for use by DOTS source generators.
• BlobAssetComputationContext made internal.

Fixed

• Baker IEntitiesPlayerSettings were not setup correctly if the com.unity.platforms package was not installed/present in the project.
• IJobEntity now no longer caches the default query when scheduling with a dynamic query. For example. new MyJob().Schedule(); will use the query matching its execute signature whereas new MyJob().Schedule(myQuery) will now only use myQuery. This is useful in cases like RequireMatchingQueriesForUpdate, where you don't want to accidentally create extra queries.
• Jobs implementing IJobEntity can now be created in one assembly and scheduled in another.
• The [WithDisabled] attribute when applied to a job implementing IJobEntity now overrides the implicit All query defined by the signature of Execute. E.g. Execute(MyComp a) and [WithDisabled(typeof(MyComp))] now defines a query of EntityQuery(all={}, disabled=MyComp). This is useful in cases where you want to enable all components of type X which are present, but disabled.
• WriteGroup support in transform v2 LocalToWorldSystem code should now work correctly.
• Fixed compilation issue with 23.1/23.2*
• Detection of circular ordering dependencies between systems is now correct.
• Chaining EntityQuery methods with bulk operation methods is now supported.
• Docs and samples for ECB systems now accurately reflect recommended usage. Fixed issue during TypeManager.Initialize where managed components with a field containing a circular type definition may throw ArgumentException: An item with the same key has already been added.
• Calling Release on a WeakObjectReference<GameObject> will no longer log errors in the editor.
• Zero-sized ("tag") enableable components were not always correctly enabled by default, when added to an entire chunk (such as via EntityManager.AddComponent<EnableableTag>(query)).
• Fixed issue with DotsGlobalSettings reporting the incorrect PlayType when switching from DedicatedServer to another standalone build target.
• Fixed TypeManager initialization causing a crash in the Entities Hierarchy.
• If you schedule an IJobEntity instance with a custom query that doesn't contain the components required for the Execute() method to run, a readable and actionable runtime exception is now thrown when safety checks are enabled.
• EntityCommandBuffer.Dispose() can no longer trigger a stack overflow when disposing large command buffers.
• Throw a readable, actionable compile-time error informing users that RefRO<T>, RefRW<T>, EnabledRefRO<T>, EnabledRefRW<T>, DynamicBuffer<T> and UnityEngineComponent<T> may not be used with generic types.
• A foreach iterating over an EntityQuery with enableable components now iterates over the correct entities.
• Re-added obsolete baker functions
• The accidental exposure of package internals to "Assembly-CSharp" was reverted.
• Default the build system to use the client settings if the package com.unity.netcode is not installed when the active platform is dedicated server.
• Entities.WithStructuralChanges().ForEach() now correctly handles enableable components.
• Allow components to contain nested native containers. Previously the TypeManager would throw during initialization if a component contained a a nested NativeContainer field. Note: NativeContainers still cannot be verified to be safely accessed when used in jobs. So, if a component contains a nested NativeContainer field, that component can only be accessed from the main thread.
• Entities Hierarchy correctly selects the subscenes
• Invalid entity warning in Inspector window with runtime data mode is only applied to entities or game objects that can be converted to entities.
• Issue with IJ...

1.0.0-pre.47

[1.0.0-pre.47] - 2023-02-28

Fixed

• Stripping (e.g. on il2cpp) now won't strip whole assemblies that have important systems, like graphics.
• Generic systems created at runtime no longer break sorting functionality.

1.0.0-pre.44

[1.0.0-pre.44] - 2023-02-13

Added

• Added RegisterBindingAttribute(string authoringField, Type runtimeComponent, string runtimeField) to provide better control when registering nested types in authoring components.
• RuntimeContentSystem.LoadContentCatalog allows for starting the content delivery and update process when ENABLE_CONTENT_DELIVERY is defined. The automatic update is no longer triggered when the applications starts.
• Streaming samples.
• RemoteContentCatalogBuildUtility.BuildContent helper method added to allow building player content without having to rebuild the player. This is needed in order for developers to create their own publishing workflow for remote content delivery.
• Added missing SceneSystem.UnloadScene prototype.
• Generic IJobEntity jobs are not yet supported. Added a proper error to indicate this instead of a compiler error.
• SceneSystem.UnloadScene(WorldUnmanaged world, Entity sceneEntity, bool fullyUnload)
• ManagedAPI.GetComponentTypeHandle now let's you get a typehandle to Class IComponentData.
• Baking systems from the excluded baking assemblies are also filtered out during baking.
• Two new categories of component types can be provided when creating an EntityQuery. Components in the Disabled list must be present on matching entities, but must be disabled. Components in the Absent` list must not be on the entity at all.
• Companion objects need to always instantiate since the content manager reuses loaded objects.
• A new WorldSystemFilterFlags called Streaming to identify all the systems involved in streaming.
• Add AlwaysIncludeBakingSystem internal attribute to run baking systems from excluded baking assemblies
• WorldSystemFilter to the runtime version of ResolveSceneReferenceSystem.
• DependsOnLightBaking can be called from bakers to register a dependency against light mapping data.
• Added support for managed (shared) components serialization in DOTS runtime.
• debug only check to prevent disposal of blob assets managed by a blob asset store.

Changed

• ComponentTypeHandle and BufferTypeHandle now more consistently use their cache of per-archetype metadata to accelerate common operations like .Has<T>(), .DidChange<T>() and .GetNativeArray<T>().
• ComponentLookup and BufferLookup now more consistently use their cache of per-archetype metadata to accelerate common operations like .HasComponent<T>(), .IsComponentEnabled<T>() and .SetComponentEnabled<T>().
• Upgraded to use Roslyn 4.0.1
• Added better support for vector type fields in BindingRegistry.
• Unmanaged shared components are serialized as blittable data.
• ISystem now doesn't need BurstCompile on the struct. Thus bursting a system simply means to put BurstCompile on either OnCreate, OnStartRunning, OnUpdate, OnStopRunning, or OnDestroy.
• The "a system could not be added to group" error message now contains the name of the World affected for easier debugging
• Nested native containers are protected against in any type attributed with [NativeContainer]
• Unmanaged shared components are no longer boxed when collecting BlobAssetReferences.
• EditorEntityScenes.GetSubScenes was made public in order to gather subscenes to pass to the BuildContent API.
• EntityManager.GetAllUniqueSharedComponents now takes an AllocatorManager.AllocatorHandle instead of an Allocator enum parameter allowing for custom allocators to be used when allocating the NativeList<T> return value. Allocator implicitly converts to AllocatorManager.AllocatorHandle so no action is required to call the changed API.
• IJobEntity refactored to IncrementalGenerator.
• IJobEntity now doesn't default to outputting generated files in Temp/GeneratedCode/***. To turn it on use DOTS_OUTPUT_SOURCEGEN_FILES. Turning it on will cost Compilation Time.
• Replaced .Name with .FullName for duplicated component message in baking.
• Removed IIsFullyUnmanaged due to obtrusiveness when compilation fails. Instead gives runtime error when incorrectly scheduling managed IJobEntity.
• ManagedComponents and Shared Managed Components can now be Scheduled in IJobEntity (ScheduleParallel still not allowed. Runtime error will be thrown if you try.)
• Invalid entities now show their index and version when viewed in the inspector
• In Bakers AddTransformUsageFlags now takes an entity instead of a GameObject or a Component.
• Baking log output to be more succinct.
• In cases where there are no attributes constraining the order of system creation, updating, and destruction, the order will have changed to enable optimizations. If you have mysterious bugs after this update, check for missing [CreateAfter], [CreateBefore], [UpdateAfter], and [UpdateBefore] attributes.

Deprecated

• Deprecated RegisterBindingAttribute(Type runtimeComponent, string runtimeField, bool generated). Vector type fields can now be registered automatically without the generated option.
• SceneSystem.UnloadParameters and SceneSystem.UnloadScene receiving SceneSystem.UnloadParameters as parameters.

Removed

• SourceGen no longer outputs .cs files in Temp/GeneratedCode by default, because most IDEs such as Rider and Visual Studio support SourceGen output. If you want to emit the output (at the cost of significant compilation time), use the DOTS_OUTPUT_SOURCEGEN_FILES define.
• From Unity Editor version 2022.2 and later, the Auto Generate mode in the Lighting window is unavailable with the Entities package. This is because when you generate lighting in a project, the Unity Editor opens all loaded subscenes, which might slow down Editor performance. On demand baking is still available and is the recommended way of generating lighting.
• Tooling to re-write user files to add missing partial keywords to systems.

Fixed

• A selection issue with keyboard arrow keys in Entities Hierarchy window.
• GetComponent on Transform triggers now a rebake when the gameobject is reparented.
• Removed unnecessary test assemblies from always being loaded in projects.
• In DOTS Runtime, shared components containing managed references could generate incorrect results when calling TypeManager.Equals and/or TypeManager.GetHashCode. We also now reinforce that all shared components containing managed references must implement IEquatable<>
• Using EnabledRefRO<T> and EnabledRefRW<T> parameters in IJobEntity.Execute() with zero-sized enableable components is now supported.
• The transform system no longer increments the change version of WorldTransform and LocalToWorld on all world-space entities every frame. This prevents entity hierarchies from being processed redundantly, even if their root entity had not moved since the last update.
• Fixes lightmaps for player builds
• Creating multiple additional entities in a baker now scales linearly
• Fixed the behavior of EntityRemapUtility.HasEntityReferencesManaged for types where Entity or BlobAsset reference fields are succeeded by two or more strings.
• Setting a shared component to its default value using an EntityCommandBuffer could cause the default value to be duplicated and this would prevent query filtering from working correctly.
• Using EnabledRefXX<T> and RefXX<T> wrappers on the same component in the same IJobEntity.Execute() method no longer throws compiler errors.
• It is now possible to force reimport a single or multiple subscenes from the inspector when the last import of the subscene failed.
• Fix SubScene issue with File -> Save As when having a SubScene as the Active Scene.
• EntityQueryEnumerator.MoveNextEntityRange() now consistently returns the correct entityCount value.
• IJobEntity compile error when using an aspect's lookup type as field.
• Invalid subscene nodes issues in Entities Hierarchy window.
• Some EntityManager methods (including RemoveComponent() were not calling their Burst-compiled implementations.
• Badly formatted error messages when they are emitted while in burst-compiled code.
• Performance issue in Entities Hierarchy when opening large subscenes.
• An EntityCommandBuffer containing references to managed components will no longer throw an exception if it is disposed from a Burst-compiled context.
• Errors for DynamicSharedComponentTypeHandle were reporting as DynamicComponentTypeHandle
• Entities Hierarchy reset properly after test runner execution.
• Fixed a small memory leak that would occur when calling EntityManager.GetAllUniqueSharedComponents with an unmanaged component T type.
• Improve subscene handling in Entities Hierarchy
• Stack overflow in source generators when IComponentData has a cycle.
• Fix a NullReferenceException happening in the BakingFilterSettings when an assembly definition added in the excluded list of baking assemblies is missing.
• First cross reference to section 0 being lost.
• Fix missing subscene sections to load and unload from the subscene inspector.
• Aspect generator cache flush. Nested aspects no longer cause compilation error when their fields are changed.
• Added implicit dependency on transform hierarchy for transform bakers.
• Section 0 unloading is delayed until all the other sections are unloaded.
• Loading scene sections with BlockOnStreamIn failed if section 0 wasn't loaded first.
• Components window's list view item height is fixed to the correct value.
• IJobEntityChunkBeginEnd now doesn't update change version if shouldExecuteChunk is false.
• The detection of duplicate components during baking was failing between different baking passes.
• Issue with types used in codegen not being found if there if they exist in a more namespace name that aliases with a more immediate namespace name.
• The following ArchetypeChunk methods may now be invoked on zero-sized components without triggering any exception: GetNativeArray<T>(ref ComponentTypeHandle<T> typeHandle), GetComponentDataPtrRO<T>(ref ComponentTypeHandle<T> typeHandle), `GetComponentDataPtrRW(ref...

1.0.0-pre.15

[1.0.0-pre.15] - 2022-11-16

Added

• Support serializing UnityEngine.AnimationCurves in managed components.
• Changing shared component data (managed or unmanaged) is now tracked by the entities structural changes profiler module.
• WorldUnmanaged.GetAllSystems
• Support for enabling or disabling components in the entity inspector, for components that derives from the IEnableableComponent interface.
• TypeManager.TypeIndex type providing type safety and improved debugging working with type indices given from the TypeManager.
• Missing docs for Scratchpad and UpdateAllocator public APIs.
• ComponentTypeSet now has a debugger type proxy, to show the list of components it contains.
• DotsPlayerSettings can provide their own set of custom scripting defines.
• UnityObjectRef now implements IEquatable<UnityObjectRef>.
• Support for RefRW<T>, RefRO<T>, EnabledRefRW<T> and EnabledRefRO<T> parameters in IJobEntity.Execute().
• Added convenience methods for adding Chunk Components to an EntityQueryBuilder.
• Docs to provide an overview of prebuilt custom allocators.
• SystemAPI.ManagedAPI.HasComponent, SystemAPI.ManagedAPI.GetComponent, SystemAPI.ManagedAPI.TryGetComponent, SystemAPI.ManagedAPI.GetSingleton, SystemAPI.ManagedAPI.TryGetSingleton.
• managed EntityQuery.TryGetSingleton
• SystemAPI.Query<ManagedAPI.UnityEngineComponent<MyUnityEngineComp>> support.
• EntityQuery.TryGetSingletonRW and SystemAPI.TryGetSingletonRW
• Workflow for preparing builds for publishing
• Workflow for preparing content updates for published builds
• Runtime functionality to download and update remote content
• Profiler module for the runtime content manager that tracks loading information.
• SystemAPI.IsComponentEnabled, SystemAPI.IsBufferEnabled, SystemAPI.ManagedAPI.IsComponentEnabled to get component enabledness from an entity. To do this in jobs, do so in ComponentLookup/BufferLookup.
• SystemAPI.SetComponentEnabled, SystemAPI.SetBufferEnabled, SystemAPI.ManagedAPI.SetComponentEnabled to set component enabledness from an entity. To do this in jobs, do so in ComponentLookup/BufferLookup.
• RequireForUpdateWithSystemComponent to SystemBase and ISystem to help explain that system components won't normally partake in queries without explicitly mentioning it.
• EntityQueryBuilder ChunkComponent calls to SystemAPI.EntityQueryBuilder for better symmetry.
• Added EntityCommandBuffer.ParallelWriter.SetEnabled(Entity,bool) method, for parity with the main-thread interface.
• A isReadOnly field (with default arg) to TryGetSingletonBuffer so it matches its cousin GetSingletonBuffer
• ArchetypeChunk.Has and ArchetypeChunk.HasChunkComponent for ease of checking (useful for IJobEntityChunkBeginEnd)
• IJobEntityChunkBeginEnd - allowing you to run code at the start and end of chunk iteration.
• SystemAPI.GetXTypeHandle to easily get cached and .Update'd handles :3
• The new tag component PropagateLocalToWorld must be added to any entity which needs its children to inherit its full LocalToWorld matrix, instead of the more compact WorldTransform representation. This path is slightly slower, but supports additional features like PostTransformMatrix (for non-uniform scale), and interpolation by the Physics and Netcode packages.
• Added ArchetypeChunk.IsComponentEnabled(ref DynamicComponentTypeHandle).
• ContentDeliverySystem.UpdateContent API
• Added No aspects message for Aspects tab in Inspector when no aspect is available for selected entity.
• Support for sticky data mode to the Entities Hierarchy window and the Inspector window.
• Support for automatic data mode switching to the Entities Hierarchy window and the Inspector window.

Changed

• Entities package test components such as EcsTestData are no longer part of the package's public API; they are only intended for internal package testing.
• WorldUnmanaged.CurrentTime renamed to WorldUnamanged.Time
• WorldUnmanaged.TryGetSystemStateForId is now internal
• WorldUnmanaged.IsCreated is now public
• SystemState.ShouldRunSystem is now public
• Renamed the fields of EntityBlobRefResult to match the C# coding standard.
• Renamed the DOTS Hierarchy window to Entities Hierarchy.
• Renamed the DOTS sub-menu from the top-level Window menu to Entities.
• Renamed the DOTS section in the Preferences window to Entities.
• Changed the order of the items under Window>Entities to be deterministic.
• Moved the baking options to the DOTS Editor preferences page.
• EntityQueries created via EntityManager.CreateEntityQuery or EntityQueryBuilder.Build(EntityManager) will be owned by the EntityManager and be disposed by the EntityManager when it is destroyed.
• RuntimeContentManager API for loading and managing Unity engine objects loaded from Content Archives.
• WeakObjectReference can be used to manage weak objects at runtime.
• Asset bundles are no longer build and loaded for referenced unity objects. AssetBundleManager class has been removed.
• Bakers for base component types and decorated with [BakeDerivedTypes] are evaluated before bakers for derived component types.
• Renamed EntityCommandBuffer.*ForEntityQuery methods to be their singular overload equivalents EntityCommandBuffer.*. E.g. EntityCommandBuffer.DestroyEntitiesForEntityQuery is now an overload in EntityCommandBuffer.DestroyEntity. EntityCommandBuffer is now more in line with EntityManager!.
• EntityQuery.CalculateEntityCount(NativeArray<Entity>)
• EntityQuery.CalculateEntityCountWithoutFiltering(NativeArray<Entity>)
• EntityQuery.MatchesAny(NativeArray<Entity>)
• EntityQuery.MatchesAnyIgnoreFilter(NativeArray<Entity>)
• EntityQuery.ToEntityArray(NativeArray<Entity>, Allocator)
• EntityQuery.ToComponentDataArray(NativeArray<Entity>, Allocator)
• Entities.ForEach.WithFilter(NativeArray<Entity>)
• Renamed BufferLookup.IsComponentEnabled to BufferLookup.SetBufferEnabled and BufferLookup.SetComponetEnabled to BufferLookup.SetBufferEnabled.
• Renamed IJobEntity EntityInQueryIndex to EntityIndexInQuery to match name scheme found in ChunkIndexInQuery and EntityIndexInChunk
• Renamed BlobAssetStore.Remove to BlobAssetStore.TryRemove, to better convey its functionality, as it only removes the BlobAsset if it is present.
• added some missing xml docs
• removed cleanup call from RuntimeContentSystem.OnDestroy as this could be called multiple times when there are multiple worlds
• Baked primary entities no longer have an implicit dependency on the Transform component.
• Removed the inner TransformData struct from WorldTransform, LocalTransform and ParentTransform (and instead use extension methods and properties). Position/Rotation/Scale can now be accessed directly on the transform type itself.
• ComponentTypeHandle, BufferTypeHandle, DynamicComponentTypeHandle, and DynamicSharedComponentTypeHandle arguments to ArchetypeChunk methods are now passed by ref instead of by value. This facilitates a caching optimization that will be implemented in a future release.
• Renamed the PostTransformMatrix component to PostTransformScale, and changed its value type to float3x3.
• Searching the Entities hierarchy using the component filter now treats multiple entries as AND rather than OR.
• Updated transform documentation.
• Improved performance of EntityManager.DestroyEntity(EntityQuery)
• The build settings are no longer stored in the Assets folder.
• It's now a compile error to schedule with managed code (for IJobEntity and IJobChunk)
• Blob asset safety verifier rewritten as a Roslyn analyzer (results in domain reload time improvements and IDE support with CodeFixes).
• Blob assets now create a compile error if it contains a pointer e.g. fixed byte[16].
• Blob assets now warn on new assignments e.g. var test = new MyBlob() and var test = default(MyBlob).
• ComponentTypeSet is now a readonly struct, which is passed by in instead of by value

Deprecated

• rename EntityManager.CompleteAllJobs to EntityManager.CompleteAllTrackedJobs, to more accuractly describe what it is doing.
• SystemState.Time and SystemBase.Time has been deprecated in favor of World.Time and SystemAPI.Time
• [WithEntityQueryOptions] for IJobEntity becomes [WithOptions] to be consistent with EntityQueryBuilder and SystemAPI.QueryBuilder
• SystemAPI.Query.WithEntityQueryOptions becomes SystemAPI.Query.WithOptions to be consistent with EntityQueryBuilder and SystemAPI.QueryBuilder
• ArchetypeChunk.ChunkEntityCount is now deprecated. It is guaranteed to always have the same value as ArchetypeChunk.Count, and the latter should be preferred.
• SystemAPI duplicated API in ComponentSystemBase. HasSingleton, GetSingleton, GetSingletonRW, GetSingletonBuffer, TryGetSingleton, TryGetSingletonBuffer, SetSingleton, GetSingletonEntity, TryGetSingletonEntity. Use SystemAPI alternatives instead.
• SystemAPI duplicated API in ComponentSystemBaseManagedComponentExtensions. GetSingleton, GetSingletonRW, SetSingleton. Use SystemAPI alternatives instead.
• SystemAPI duplicated API in SystemBase. GetComponent, SetComponent, HasComponent, GetBuffer and Exists. Use SystemAPI alternatives instead.

Removed

• ISystemBase as the old name for good, use the new name ISystem
• Removed the Journaling sub-menu from the DOTS top-level menu. Enable Entities Journaling can be set through the Preferences window or from the Journaling window. Export to CSV can be triggered from the Journaling window.
• The "Add missing partials keyword to systems" menu item has been removed. It was intended to help older DOTS projects update to the 0.50.x, and is no longer necessary for 1.0 and beyond.
• Removed BufferAccessor constructor from the public API. Use methods like GetBufferAccessor() to create instances of this type.
• Removed unit-test helper method `Ar...

1.0.0-exp.12

[1.0.0-exp.12] - 2022-10-19

Changed

• updates to package dependencies

1.0.0-exp.8

[1.0.0-exp.8] - 2022-09-21

Added

• Added GetSingletonBuffer(bool isReadOnly) method on ComponentSystemBase and EntityQuery, for use with singleton DynamicBuffers. No SetSingletonBuffer() is needed; once you have a copy of the buffer, its contents can be modified directly.
• CreateSystemsAndLogException() creates managed and unmanaged systems such that all the system instances are created before their OnCreate are called. The unmanaged equivalent is GetOrCreateUnmanagedSystemsAndLogException().
• AudioSource is supported as a companion component in subscenes
• Components and buffer components can now implement the IEnableableComponent interface to be enabled and disabled at runtime without structural changes. See the Entities manual for more details on this feature.
• TypeOverridesAttribute can be applied to components to force a type to appear to have no entity and/or BlobAssetReference fields. This attribute is useful for managed components to reduce time taken during deserialization since un-sealed managed field types cannot statically be checked for entity/blob references and thus must be scanned at runtime.
• EntityManager.MoveComponent supports moving managed components to other entities.
• Added public bool HasBuffer<T>(Entity entity) where T : struct, IBufferElementData to EntityManager, which can be used to check whether an entity has a dynamic buffer of a given IBufferElementData type
• Added protected internal bool HasBuffer<T>(Entity entity) where T : struct, IBufferElementData to SystemBase, which can be used to check whether an entity has a dynamic buffer of a given IBufferElementData type
• Added DynamicBuffer.Resize(int length, NativeArrayOptions options)
• Added BufferTypeHandle.Update(ref SystemState) matching the same methods on ComponentTypeHandle to improve main thread performance
• Added EntityManager.EntityManagerDebug.GetLastWriterSystemName(), a debug method to help identify which system last touched component data in a chunk
• Added EntityManager.AddComponent(NativeArray<Entity>, ComponentTypeSet) and EntityManager.RemoveComponent(NativeArray<Entity>, ComponentTypeSet) to perform batch component operations on a specific set of entities
• Added EntityCommandBuffer.SetEnabled(Entity e, bool value) to enable/disable entities from an EntityCommandBuffer.
• Added property UpdateAllocatorEnableBlockFree in World to enable or disable world update allocator to free individual block when no memory is allocated in that block.
• Added SystemBase.Exists(Entity e) to check if an Entity exists and is valid. Can be used inside of Entities.ForEach.
• GetStorageInfoLookup can now be used inside E.FE
• ComponentType now provides a ToFixedString method as a Burst-compatible way of generating a component's name and access mode.
• Entities.ForEach lambdas in ISystem may access system state through Systems proxy type
• Added IAspect<T> interface for declaring aspects. See the user manual for more details on this feature.
• Added ComponentDataRef<T>, used inside an aspect struct declaration as a proxy to the component data. It is also used during the generation of aspect code to identify the composition of the aspect.
• Added OptionalAttribute, used for declaring optional components inside an aspect declaration.
• Added DisableGenerationAttribute, used to disable source generation of aspect declarations.
• Added ComponentDataFromEntity.GetDataRef and GetDataRefOptional, used to create ComponentDataRef<T> from entity.
• Added GetAspect<T>(Entity) and GetAspectRO<T>(Entity) to both SystemBase and SystemState, used to retrieve an aspect from an entity.
• Aspect sample in EntitiesSample project. Demonstrate a few use-case using with a simple R.P.G. game design.
• Added ComponentType.Combine(), which combines multiple arrays of components types and removes duplicates in the process.
• Added EntityQueryEnumerator, a new public low-level API to efficiently enumerate entities in an EntityQuery on the main thread.
• Added TransformAspect, an aspect-based interface to transform data.
• New EntityQueryOptions.IgnoreComponentEnabledState flag forces an EntityQuery to match all entities in all matching chunks, regardless of their enabled-bit values.
• [WithAll] Attribute that can be added to a struct that implements IJobEntity. Adding additional required components to the existing execute parameter required components.
• [WithNone] Attribute that can be added to a struct that implements IJobEntity. Specifying which components shouldn't be on the entity found by the query.
• [WithAny] Attribute that can be added to a struct that implements IJobEntity. Specifying that the entity found by this query should have at least one of these components.
• [WithChangeFilter] Attribute that can be added to a struct that implements IJobEntity, as well as on component parameters within the signature of the execute method. This makes it so that the query only runs on entities, which has marked a change on the component specified by the [WithChangeFilter].
• [WithEntityQueryOptions] Attribute that can be added to a struct that implements IJobEntity. Enabling you to query on disabled entities, prefab entities, and use write groups on entities.
• Added BufferLookup.Update, allowing users to update a reference within a system instead of constructing a new lookup object every frame.
• Relaxed entity creation structural safety checks in certain cases (for example, creating an entity in an unrelated archetype while iterating over a query).
• Added [CreateBefore] and [CreateAfter] attributes to control the explict ordering for when systems OnCreate method is invoked relative to other systems.
• Added static AspectQueryEnumerable<T> Query<T>() where T : struct in the SystemAPI class, allowing users to perform foreach iteration through a query without having to manually set up any arguments beforehand. This method may only be used inside methods in ISystem types.
• IJobEntity supports Aspects in Execute parameters.
• Added Update(SystemBase) and Update(SystemState) to DynamicComponentTypeHandle, SharedComponentHandle, DynamicSharedCompoentHandle, and EntityTypeHandle, in order to allow for incremental updates.
• Added warnings when using slow API's from ISystem.OnUpdate. (managed SystemBase is unchanged). For example, SystemState.GetEntityQuery or SystemState.GetTypeHandle. We expect users to store these objects on the system as fields and use incremental-update methods like ComponentTypeHandle<>.Update in OnUpdate instead.
• Added new menu item for exporting entities journaling data to CSV.
• Importance scaling: Custom entry for per-chunk tile data.
• Added TypeManager.HasDescendants(), TypeManager.IsDescendantOf(), and TypeManager.GetDescendantCount() for checking the inheritance relationship between types.
• ComponentSystemBaseManagedComponentExtensions.GetSingletonRW<T> and ComponentSystemBase.GetSingletonRW<T>() to access singletons by reference in systems, with read/write access to the data.
• Added EntityQuery.GetSingletonRW<T>() to access singletons by reference from an EntityQuery, with read/write access to the data.
• Added new singleton access methods EntityQuery.TryGetSingleton<T>(out T), EntityQuery.HasSingleton<T>(), EntityQuery.TryGetSingletonBuffer<T>(out DynamicBuffer<T>), and EntityQuery.TryGetSingletonEntity<T>(out Entity)
• Added new singleton access methods to SystemAPI: HasSingleton<T>(), GetSingleton<T>(), GetSingletonBuffer<T>(bool), TryGetSingleton<T>(out T), TryGetSingletonBuffer<T>(out DynamicBuffer<T>), SetSingleton<T>(T value), GetSingletonEntity<T>(), TryGetSingletonEntity<T>(out Entity), and GetSingletonRW<T>() (all of which are now supported inside Systems).
• Bakers now support declaring TransformUsageFlags which specifies how the transform component will be used at runtime
• Some extra EntityCommandBuffer debug checks can now be enabled during playback, by setting EntityCommandBuffer.ENABLE_PRE_PLAYBACK_VALIDATION to true.
• QueryEnumerable<T> SystemAPI.Query<T>() can now accept up to 8 type arguments, i.e. QueryEnumerable<(T1, T2)> Query<T1, T2>(), QueryEnumerable<(T1, T2, T3)> Query<T1, T2, T3>(), and so forth. The maximum number of type arguments is set to 8, and correspondingly the maximum number of elements in the returned tuple is 8. This is in accordance with current C# convention.
• Idiomatic foreach iteration through aspects/components is now supported inside SystemBase types.
• Added GetEntityDataPtrRO(), GetRequiredComponentDataPtrRO(), and GetRequiredComponentDataPtrRW() methods to ArchetypeChunk (mostly for internal use, to provide efficient access to a Chunk's Entity array for generated job code).
• The DOTS Hierarchy content is now filtered based on the currently selected DataMode
• Added an indicator to the items in the DOTS Hierarchy when they are in the Runtime DataMode to differentiate them from items in the Authoring DataMode.
• Added netcode-aware WorldSystemFilterFlags and WorldFlags.
• Added SystemAPI.GetComponent, SystemAPI.SetComponent, SystemAPI.GetBuffer, SystemAPI.HasBuffer, SystemAPI.GetAspect, SystemAPI.GetAspectRO.
• Added [ChunkIndexInQuery] attribute, to acquire the current index of the chunk inside the query an IJobEntity is iterating over.
• Added [EntityIndexInChunk] attribute, to acquire the current index of the entity inside the chunk an IJobEntity is iterating over.
• Add an opt-in define to disable baking by default: ENABLE_LEGACY_ENTITY_CONVERSION_BY_DEFAULT
• Added [RequireMatchingQueriesForUpdate] attribute, which causes a system to only call OnUpdate if any EntityQuery it creates matches an entity.
• Added EntityQuery methods for asynchronous bulk en...

0.51.1-preview.21

[0.51.1] - 2022-06-27

Changed

• Package Dependencies
  • com.unity.jobs to version 0.51.1
  • com.unity.platforms to version 0.51.1
  • com.unity.collections to version 1.4.0
  • com.unity.jobs to version 0.70.0

Fixed

• an issue with source generator that was causing a compilation error when the generator was unable to create the temporary output folder.
• an issue with netcode source generator that was trying to run on assembly that did not have the right references and also when the project path was not assigned, making impossible to load the templates files.
• Entities.ForEach in method with nullable parameter types.
• SetComponent in Entities.ForEach with argument that has an element accessor.

[0.51.0] - 2022-05-04

Changed

• Package Dependencies
  • com.unity.jobs to version 0.51.0
  • com.unity.platforms to version 0.51.0
  • com.unity.mathematics to version 1.2.6
  • com.unity.collections to version 1.3.1
  • com.unity.burst to version 1.6.6
• Increased the maximum number of shared components per entity from 8 to 16.
• Updated dependency on version of com.unity.roslyn package that will work with both Unity 2020 and Unity 2021.

Fixed

• DOTS Entities throws a compilation error when using named arguments.
• Fix Create -> ECS -> System template now adds partial keyword.
• Fixed a possible memory stomp triggered by specific sequences of ComponentDataFromEntity or BufferFromEntity calls.
• EntityQuery.CopyFromComponentDataArray() and EntityQuery.CopyFromComponentDataArrayAsync() now correctly set the change version of any chunks they write to.
• If the value of the Parent component of an entity is changed while the previous parent entity was destroyed at the same time, an exception could be thrown during the next update of the transform system.
• Changes to ComponentData made outside of Systems will be properly detected by EntityQueries with changed version filters.
• EntityQuery objects are consistently compared, regardless of which version of GetEntityQuery is called.

Added

• New BufferTypeHandle.Update() method. Rather than creating new type handles every frame in OnUpdate(), it is more efficient to create the handle once in a system's OnCreate(), cache it as a member on the system, and call its .Update() method from OnUpdate() before using the handle.
• SystemBase.GetEntityQuery can now take an EntityQueryDescBuilder.

0.51.0-preview.32

[0.51.0] - 2022-05-04

Changed

• Package Dependencies
  • com.unity.jobs to version 0.51.0
  • com.unity.platforms to version 0.51.0
  • com.unity.mathematics to version 1.2.6
  • com.unity.collections to version 1.3.1
  • com.unity.burst to version 1.6.6
• Increased the maximum number of shared components per entity from 8 to 16.
• Updated dependency on version of com.unity.roslyn package that will work with both Unity 2020 and Unity 2021.

Fixed

• DOTS Entities throws a compilation error when using named arguments.
• Fix Create -> ECS -> System template now adds partial keyword.
• Fixed a possible memory stomp triggered by specific sequences of ComponentDataFromEntity or BufferFromEntity calls.
• EntityQuery.CopyFromComponentDataArray() and EntityQuery.CopyFromComponentDataArrayAsync() now correctly set the change version of any chunks they write to.
• If the value of the Parent component of an entity is changed while the previous parent entity was destroyed at the same time, an exception could be thrown during the next update of the transform system.
• Changes to ComponentData made outside of Systems will be properly detected by EntityQueries with changed version filters.

Added

• New BufferTypeHandle.Update() method. Rather than creating new type handles every frame in OnUpdate(), it is more efficient to create the handle once in a system's OnCreate(), cache it as a member on the system, and call its .Update() method from OnUpdate() before using the handle.
• SystemBase.GetEntityQuery can now take an EntityQueryDescBuilder.

[0.50.1-preview.3] - 2022-04-28

Changed

Release preparations, no functional changes.

0.50.1-preview.2

[0.50.1-preview.2] - 2022-04-20

Changed

Release preparations, no functional changes.

[0.50.1-preview.1] - 2022-04-07

Added

• Documentation on EntityCommandBuffer public functions including ParallelWriter and EntityCommandBufferManagedComponentExtensions.
• Hybrid assemblies will not be included in DOTS Runtime builds.
• [WithAll] Attribute that can be added to a struct that implements IJobEntity. Adding additional required components to the existing execute parameter required components.
• [WithNone] Attribute that can be added to a struct that implements IJobEntity. Specifying which components shouldn't be on the entity found by the query.
• [WithAny] Attribute that can be added to a struct that implements IJobEntity. Specifying that the entity found by this query should have at least one of these components.
• [WithChangeFilter] Attribute that can be added to a struct that implements IJobEntity, as well as on component parameters within the signature of the execute method. This makes it so that the query only runs on entities, which has marked a change on the component specified by the [WithChangeFilter].
• [WithEntityQueryOptions] Attribute that can be added to a struct that implements IJobEntity. Enabling you to query on disabled entities, prefab entities, and use write groups on entities.
• Diagnostic suppressor to ignore specific generation of CS0282 warnings due to codegen.
• SystemBase.GetBuffer takes an optional isReadOnly parameter.

Changed

• DOTS Hierarchy now display SubScenes' state (opened, livelinked, closed or not loaded).
• When using EntityManager.SetName with a managed string as a parameter, if a string longer than 61 characters is used, the string will be truncated to fit within an EntityName,
• Improved the performance of the EntityQuery matching chunk cache in applications with many empty archetypes.
• Removed IJobForeach, due to long notice of deprecation
• Changed LiveLinkPatcher and LiveLinkPlayerSystem to use IJobEntityBatch, due to removal of IJobForeach
• Changed docs from IJobForeach and IJobChunk to refer to IJobEntity, and IJobEntityBatch respectivly
• Changed IJE out of DOTS_EXPERIMENTAL

0.50.0-preview.24

[0.50.0] - 2021-09-17

Added

• Window > DOTS > Entities window to show all Entities in a world in real time, with ability to search, select each, and inspect it via the Inspector.
• Window > DOTS > Components window to show all Component types, with ability to search, select each, and inspect it via the Inspector.
• Window > DOTS > Systems window to show all Systems running in a world, categorized by System Group, with ability to search, select each, and inspect it via the Inspector.
• Introduced two new ECS specific Window > Analysis > Profiler modules: * Entities Structural Changes profiler module can record which world/system produced a structural change, and how much time it cost per frame. * Entities Memory profiler module can record which world/system allocates memory chunks, with additional details per archetype.
• ArchetypeChunk.GetComponentDataPtrRO() and ArchetypeChunk.GetComponentDataPtrRW() provide unsafe raw access to a chunk's component data, as a lower-overhead alternative to ArchetypeChunk.GetNativeArray()
• ComponentTypeHandle.Update() allows ComponentTypeHandles to be created once at system creation time, and incrementally updated each frame before use.
• Adds clearer message when TypeManager hasn't been initialized yet, instead of only reporting a component type we don't know about has been requested.
• Disabled entities in Entity Window now have the same style as the disabled gameobjects in the gameobject hierarchy
• Go-to button to update Inspector content to reflect selected system and highlight the system in the Systems window if there is one open.
• It's now possible to specify an alignment when allocating an array with BlobBuilder
• Upgraded to burst 1.5.2
• Added go-to buttons to update Inspector content to reflect selected component and highlight the component in the Components window if there is one open.
• Routines to create unmanaged systems on worlds were made available for public use
• It's now possible for a scene to contain weak asset references to other scenes and prefabs. All referenced scenes and prefabs will automatically be included in a player build. The sample in "EntitiesSamples/Assets/Advanced/WeakAssetReferences" shows how to use weak asset references to scenes and prefabs.
• Incremental conversion now tracks GameObject names to rename Entities when they change.
• New method CanBeginExclusiveEntityTransaction on EntityManager to check whether or not a new exclusive entity transaction can be made.
• Wrapper functions are added in CollectionHelper to create/allocate NativeArray from custom allocator
• Entities.ForEach() will now accept a lambda with no parameters.
• WithSharedComponentFilter now also works with two shared component parameters.
• EntityCommandBuffer has an IsEmpty property, which returns true if at least one command has been successfully recorded.
• TryGetComponent in ComponentDataFromEntity
• TryGetBuffer in BufferFromEntity
• Entities journaling, which can record ECS past events and inspected from the static class EntitiesJournaling properties.
• Allow for easier viewing of EntityCommandBuffer within an IDE through a new debug proxy.
• Within an EntityCommandBufferDebugView, each command will have a summary of the action performed before expanding the command.
• SystemRef.Update to allow updating unmanaged systems manually.
• Support WithScheduleGranularity with Entities.ForEach to allow per-entity scheduling
• EntityCommandBuffer.Instantiate() can now instantiate more than one Entity in a single command, writing the resulting entities to a NativeArray<Entity>.
• Support for fully-bursted Entities.ForEach.Run in ISystemBase systems.
• RateUtils.VariableRateManager to facilitate update rate
• DefaultWorld.BeginVariableRateSimulationEntityCommandBufferSystem
• DefaultWorld.VariableRateSimulationSystemGroup
• DefaultWorld.EndVariableRateSimulationEntityCommandBufferSystem
• Element EnableBlockFree is added to enum WorldFlags to indicate whether World.UpdateAllocator is enabled to free individual memory block.
• ComponentTypes has a new constructor variant that takes a FixedList128Bytes<ComponentType>, suitable for use in Burst-compiled code.
• EntityCommandBuffer has several new variants that target a NativeArray<Entity>, which may be more efficient in many cases than recording individual commands for individual entities.
• New Archetypes window that can display current archetype memory usage.
• IJob* types use SharedStatic so they can be burst compiled eventually
• Add ability to add missing partials during generation if DOTS_ADD_PARTIAL_KEYWORD scripting define is set.

Changed

• Added a fast path for IJobEntityBatch.RunWithoutJobs() and IJobEntityBatchWithIndex.RunWithoutJobs() where query filtering is disabled, resulting up to a 30% reduction in performance overhead.
• Merged com.unity.dots.editor package into com.unity.entities package, effectively deprecating the DOTS Editor as a standalone package. All the DOTS Editor package functionality is now included when referencing the Entities package.
• DOTS Runtime now uses source generators for codegen.
• Make parts of EntityPatcher burst compatible to prepare for burst compilation of EntityPatcher for its performance improvement.
• Entity.Equals(object compare) now returns false if the compare object is null, rather than throwing a NullReferenceException.
• Made DynamicBuffer an always blittable type (even in the Editor with safety checks on), so that it can be passed by reference to Burst function pointers.
• BlobAssetStore.ComputeKeyAndTypeHash hash calculation reduced chance of collision
• Capped the maximum number of previewable GameObjects to 100 in the Entity Conversion Preview.
• Capped the maximum number of additional entities shown to 250 in the Entity Conversion Preview.
• Improved overall performance of the Entity Conversion Preview.
• Source generators are now used as the default mode of codegen for Entities.ForEach and Generated Authoring Component. These can be disabled with SYSTEM_SOURCEGEN_DISABLED and AUTHORINGCOMPONENT_SOURCEGEN_DISABLED scripting defines if necessary. The largest change is that generated code can now be inspected and debugged (when not bursted). Generated code lives in Temp/GeneratedCode and can be stepped into with both Visual Studio and Rider.
• Documentation to highlight necessary prerequisites in the Build Configuration for making a profilable build.
• Entities window now shows prefab entities with a style similar to the one in the GameObject hierarchy
• Systems in the Entity inspector relationships tab are now sorted by scheduling order instead of creation order.
• Subscene headers are now loaded asynchronously and will no longer stall the main thread while loading.
• Performance of LiveTweaking has been improved.
• EntityDiffer capture entity changes when only entity's name is changed.
• With an IDE debugger, EntityQuery will present more information related to it. The raw view
• Debugging output for a ComponentType will present clearer info.
• The batchesPerChunk parameter to IJobEntityBatch.ScheduleParallel() has been replaced with a new ScheduleGranularity enum. Pass ScheduleGranularity.Chunk to distribute work to worker threads at the level of entire chunks (the default behavior). Pass ScheduleGranularity.Entity to distribute individual entities to each worker thread. This can improve load balancing in jobs that perform a large amount of work on a small number of entities.
  *Make generate linker xml files deterministic in order.
• Within an IDE debugger, ComponentSystemGroup will present more relevant information. The raw view will be available for those who need the precise makeup of the class.
• ComponentSystemGroup.RemoveSystemFromUpdateList and ComponentSystemGroup.RemoveUnmanagedSystemFromUpdateList can now be used when ComponentSystemGroup.EnableSystemSorting is set to false
• Add debug checks to detect "placeholder" Entities created by one EntityCommandBuffer from being passed into a different EntityCommandBuffer.
• Clarified error message when calling .Dispose() on an EntityQuery created by GetEntityQuery(). This is always an error; these queries belong to the associated system, and should never be manually disposed. They will be cleaned up along with the system itself.
• Within an IDE debugger, ArchetypeChunk will present more relevant information. The raw view will be available for those who need the precise makeup of the struct.
• Within an IDE debugger, EntityArchetype will present more relevant information. The raw view will be available for those who need the precise makeup of the struct.
• IJobEntityBatch batchIndex parameter has been renamed to batchId. Documentation regarding what values to expect from this parameter have been updated accordingly.
• Changed: Within an IDE debugger, EntityManager will present more relevant information. The raw view will be available for those who need the precise makeup of the struct.
• Changed: Within an IDE debugger, an ArchetypeChunk's OrderVersion and ChangeVersions per ComponentType will be easier to view.
• Changed: Within an IDE debugger, SystemState will present more relevant information. The raw view will be available for those who need the precise makeup of the struct.
• Changed: Within an IDE debugger, World will present more relevant information. The raw view will be available for those who need the precise makeup of the struct.
• EntityCommandBufferSystem.CreateCommandBuffer() now uses the World.UpdateAllocator to allocate command buffers instead of Allocator.TempJob. Allocations from this allocator have a fixed lifetime of two full World Update cycles, rather than being tied to the display frame rate.
• EntityCommandBuffer.AddComponentForEntityQuery<T>() now asserts if the provided T value contains a reference to a temporary Entity c...