Method WithNone
WithNone<T1>()
Add excluded component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithNone<T1>()Returns
| Type | Description |
|---|---|
| EntityQueryBuilder | The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An excluded component type |
Remarks
To match the resulting query, an Entity must not have any of the query's excluded component types.
There are several ways to exclude components from a query:
- WithAbsent<T>() matches all entities in chunks that do not have T at all.
- WithDisabled<T>() matches chunks that must have T, but only matches entities where T is disabled.
- WithNone<T>() matches both of the above cases: either the component isn't present at all, or it is present but disabled.
WithNone accepts up to seven type arguments. You can add more component types by chaining calls together.
To add component types that are not known at compile time, use WithNone<T>(ref T)
Component types added using WithNone are never written to. If the ComponentType.AccessMode field of the provided component type is ReadWrite, it will be forced to ReadOnly in the final query.
WithNone<T1, T2>()
Add excluded component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithNone<T1, T2>()Returns
| Type | Description |
|---|---|
| EntityQueryBuilder | The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An excluded component type |
| T2 | An excluded component type |
Remarks
To match the resulting query, an Entity must not have any of the query's excluded component types.
There are several ways to exclude components from a query:
- WithAbsent<T>() matches all entities in chunks that do not have T at all.
- WithDisabled<T>() matches chunks that must have T, but only matches entities where T is disabled.
- WithNone<T>() matches both of the above cases: either the component isn't present at all, or it is present but disabled.
WithNone accepts up to seven type arguments. You can add more component types by chaining calls together.
To add component types that are not known at compile time, use WithNone<T>(ref T)
Component types added using WithNone are never written to. If the ComponentType.AccessMode field of the provided component type is ReadWrite, it will be forced to ReadOnly in the final query.
WithNone<T1, T2, T3>()
Add excluded component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithNone<T1, T2, T3>()Returns
| Type | Description |
|---|---|
| EntityQueryBuilder | The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An excluded component type |
| T2 | An excluded component type |
| T3 | An excluded component type |
Remarks
To match the resulting query, an Entity must not have any of the query's excluded component types.
There are several ways to exclude components from a query:
- WithAbsent<T>() matches all entities in chunks that do not have T at all.
- WithDisabled<T>() matches chunks that must have T, but only matches entities where T is disabled.
- WithNone<T>() matches both of the above cases: either the component isn't present at all, or it is present but disabled.
WithNone accepts up to seven type arguments. You can add more component types by chaining calls together.
To add component types that are not known at compile time, use WithNone<T>(ref T)
Component types added using WithNone are never written to. If the ComponentType.AccessMode field of the provided component type is ReadWrite, it will be forced to ReadOnly in the final query.
WithNone<T1, T2, T3, T4>()
Add excluded component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithNone<T1, T2, T3, T4>()Returns
| Type | Description |
|---|---|
| EntityQueryBuilder | The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An excluded component type |
| T2 | An excluded component type |
| T3 | An excluded component type |
| T4 | An excluded component type |
Remarks
To match the resulting query, an Entity must not have any of the query's excluded component types.
There are several ways to exclude components from a query:
- WithAbsent<T>() matches all entities in chunks that do not have T at all.
- WithDisabled<T>() matches chunks that must have T, but only matches entities where T is disabled.
- WithNone<T>() matches both of the above cases: either the component isn't present at all, or it is present but disabled.
WithNone accepts up to seven type arguments. You can add more component types by chaining calls together.
To add component types that are not known at compile time, use WithNone<T>(ref T)
Component types added using WithNone are never written to. If the ComponentType.AccessMode field of the provided component type is ReadWrite, it will be forced to ReadOnly in the final query.
WithNone<T1, T2, T3, T4, T5>()
Add excluded component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithNone<T1, T2, T3, T4, T5>()Returns
| Type | Description |
|---|---|
| EntityQueryBuilder | The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An excluded component type |
| T2 | An excluded component type |
| T3 | An excluded component type |
| T4 | An excluded component type |
| T5 | An excluded component type |
Remarks
To match the resulting query, an Entity must not have any of the query's excluded component types.
There are several ways to exclude components from a query:
- WithAbsent<T>() matches all entities in chunks that do not have T at all.
- WithDisabled<T>() matches chunks that must have T, but only matches entities where T is disabled.
- WithNone<T>() matches both of the above cases: either the component isn't present at all, or it is present but disabled.
WithNone accepts up to seven type arguments. You can add more component types by chaining calls together.
To add component types that are not known at compile time, use WithNone<T>(ref T)
Component types added using WithNone are never written to. If the ComponentType.AccessMode field of the provided component type is ReadWrite, it will be forced to ReadOnly in the final query.
WithNone<T1, T2, T3, T4, T5, T6>()
Add excluded component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithNone<T1, T2, T3, T4, T5, T6>()Returns
| Type | Description |
|---|---|
| EntityQueryBuilder | The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An excluded component type |
| T2 | An excluded component type |
| T3 | An excluded component type |
| T4 | An excluded component type |
| T5 | An excluded component type |
| T6 | An excluded component type |
Remarks
To match the resulting query, an Entity must not have any of the query's excluded component types.
There are several ways to exclude components from a query:
- WithAbsent<T>() matches all entities in chunks that do not have T at all.
- WithDisabled<T>() matches chunks that must have T, but only matches entities where T is disabled.
- WithNone<T>() matches both of the above cases: either the component isn't present at all, or it is present but disabled.
WithNone accepts up to seven type arguments. You can add more component types by chaining calls together.
To add component types that are not known at compile time, use WithNone<T>(ref T)
Component types added using WithNone are never written to. If the ComponentType.AccessMode field of the provided component type is ReadWrite, it will be forced to ReadOnly in the final query.
WithNone<T1, T2, T3, T4, T5, T6, T7>()
Add excluded component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithNone<T1, T2, T3, T4, T5, T6, T7>()Returns
| Type | Description |
|---|---|
| EntityQueryBuilder | The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An excluded component type |
| T2 | An excluded component type |
| T3 | An excluded component type |
| T4 | An excluded component type |
| T5 | An excluded component type |
| T6 | An excluded component type |
| T7 | An excluded component type |
Remarks
To match the resulting query, an Entity must not have any of the query's excluded component types.
There are several ways to exclude components from a query:
- WithAbsent<T>() matches all entities in chunks that do not have T at all.
- WithDisabled<T>() matches chunks that must have T, but only matches entities where T is disabled.
- WithNone<T>() matches both of the above cases: either the component isn't present at all, or it is present but disabled.
WithNone accepts up to seven type arguments. You can add more component types by chaining calls together.
To add component types that are not known at compile time, use WithNone<T>(ref T)
Component types added using WithNone are never written to. If the ComponentType.AccessMode field of the provided component type is ReadWrite, it will be forced to ReadOnly in the final query.
WithNone<T>(ref T)
Add excluded component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(FixedList32Bytes<ComponentType>) })]
public EntityQueryBuilder WithNone<T>(ref T componentTypes) where T : INativeList<ComponentType>Parameters
| Type | Name | Description |
|---|---|---|
| T | componentTypes | A list of component types that implements INativeList<T>. For example, NativeList<T> or FixedList64Bytes<T> |
Returns
| Type | Description |
|---|---|
| EntityQueryBuilder | The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T | A container of component types |
Remarks
To match the resulting query, an Entity must not have any of the query's excluded component types.
There are several ways to exclude components from a query:
- WithAbsent<T>() matches all entities in chunks that do not have T at all.
- WithDisabled<T>() matches chunks that must have T, but only matches entities where T is disabled.
- WithNone<T>() matches both of the above cases: either the component isn't present at all, or it is present but disabled.
To add component types that are known at compile time, use WithNone<T1>()
Component types added using WithNone are never written to. If the ComponentType.AccessMode field of the provided component type is ReadWrite, it will be forced to ReadOnly in the final query.