Method WithAbsent
WithAbsent<T1>()
Add absent component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithAbsent<T1>()Returns
| Type | Description |
|---|---|
| Entity |
The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An absent component type |
Remarks
To match the resulting query, an archetype must not have any of the absent components (whether they are disabled or enabled).
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.
WithAbsent 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 With
Component types added using WithAbsent are never written to. If the Component
WithAbsent<T1, T2>()
Add absent component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithAbsent<T1, T2>()Returns
| Type | Description |
|---|---|
| Entity |
The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An absent component type |
| T2 | An absent component type |
Remarks
To match the resulting query, an archetype must not have any of the absent components (whether they are disabled or enabled).
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.
WithAbsent 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 With
Component types added using WithAbsent are never written to. If the Component
WithAbsent<T1, T2, T3>()
Add absent component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithAbsent<T1, T2, T3>()Returns
| Type | Description |
|---|---|
| Entity |
The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An absent component type |
| T2 | An absent component type |
| T3 | An absent component type |
Remarks
To match the resulting query, an archetype must not have any of the absent components (whether they are disabled or enabled).
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.
WithAbsent 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 With
Component types added using WithAbsent are never written to. If the Component
WithAbsent<T1, T2, T3, T4>()
Add absent component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithAbsent<T1, T2, T3, T4>()Returns
| Type | Description |
|---|---|
| Entity |
The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An absent component type |
| T2 | An absent component type |
| T3 | An absent component type |
| T4 | An absent component type |
Remarks
To match the resulting query, an archetype must not have any of the absent components (whether they are disabled or enabled).
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.
WithAbsent 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 With
Component types added using WithAbsent are never written to. If the Component
WithAbsent<T1, T2, T3, T4, T5>()
Add absent component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithAbsent<T1, T2, T3, T4, T5>()Returns
| Type | Description |
|---|---|
| Entity |
The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An absent component type |
| T2 | An absent component type |
| T3 | An absent component type |
| T4 | An absent component type |
| T5 | An absent component type |
Remarks
To match the resulting query, an archetype must not have any of the absent components (whether they are disabled or enabled).
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.
WithAbsent 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 With
Component types added using WithAbsent are never written to. If the Component
WithAbsent<T1, T2, T3, T4, T5, T6>()
Add absent component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData), typeof(BurstCompatibleComponentData) })]
public EntityQueryBuilder WithAbsent<T1, T2, T3, T4, T5, T6>()Returns
| Type | Description |
|---|---|
| Entity |
The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An absent component type |
| T2 | An absent component type |
| T3 | An absent component type |
| T4 | An absent component type |
| T5 | An absent component type |
| T6 | An absent component type |
Remarks
To match the resulting query, an archetype must not have any of the absent components (whether they are disabled or enabled).
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.
WithAbsent 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 With
Component types added using WithAbsent are never written to. If the Component
WithAbsent<T1, T2, T3, T4, T5, T6, T7>()
Add absent 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 WithAbsent<T1, T2, T3, T4, T5, T6, T7>()Returns
| Type | Description |
|---|---|
| Entity |
The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T1 | An absent component type |
| T2 | An absent component type |
| T3 | An absent component type |
| T4 | An absent component type |
| T5 | An absent component type |
| T6 | An absent component type |
| T7 | An absent component type |
Remarks
To match the resulting query, an archetype must not have any of the absent components (whether they are disabled or enabled).
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.
WithAbsent 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 With
Component types added using WithAbsent are never written to. If the Component
WithAbsent<T>(ref T)
Add absent component types to the query.
Declaration
[GenerateTestsForBurstCompatibility(GenericTypeArguments = new Type[] { typeof(FixedList32Bytes<ComponentType>) })]
public EntityQueryBuilder WithAbsent<T>(ref T componentTypes) where T : INativeList<ComponentType>Parameters
| Type | Name | Description |
|---|---|---|
| T | componentTypes | A list of component types that implements INative |
Returns
| Type | Description |
|---|---|
| Entity |
The builder object that invoked this method. |
Type Parameters
| Name | Description |
|---|---|
| T | A container of component types |
Remarks
To match the resulting query, an archetype must not have any of the absent components.
To add component types that are known at compile time, use With
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.
Component types added using WithAbsent are never written to. If the Component