ProcessingCounter class
Пакет: com.hypixel.hytale.component
Файл: com/hypixel/hytale/component/Store.java
implements: Lock
Поля (2)
| Модификаторы | Тип | Имя |
|---|---|---|
|
return this.count > |
0 |
|
private int |
count |
Методы (8)
| Модификаторы | Возврат | Сигнатура |
|---|---|---|
abstract |
throw new |
UnsupportedOperationExceptionthrow new UnsupportedOperationException("Conditions are not supported") |
|
public boolean |
isHeldpublic boolean isHeld() |
|
public void |
lockpublic void lock() |
|
public void |
lockInterruptiblypublic void lockInterruptibly() |
|
public Condition |
newConditionpublic Condition newCondition() |
|
public boolean |
tryLockpublic boolean tryLock() |
|
public boolean |
tryLockpublic boolean tryLock(long var1, @Nonnull TimeUnit var3) |
|
public void |
unlockpublic void unlock() |
Исходный код
Показать/скрыть
class="kw">package com.hypixel.hytale.component;
class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import com.hypixel.hytale.component.data.ForEachTaskData;
class="kw">import com.hypixel.hytale.component.data.change.ChangeType;
class="kw">import com.hypixel.hytale.component.data.change.ComponentChange;
class="kw">import com.hypixel.hytale.component.data.change.DataChange;
class="kw">import com.hypixel.hytale.component.data.change.SystemChange;
class="kw">import com.hypixel.hytale.component.data.unknown.UnknownComponents;
class="kw">import com.hypixel.hytale.component.event.EntityEventType;
class="kw">import com.hypixel.hytale.component.event.EntityHolderEventType;
class="kw">import com.hypixel.hytale.component.event.WorldEventType;
class="kw">import com.hypixel.hytale.component.metric.ArchetypeChunkData;
class="kw">import com.hypixel.hytale.component.metric.SystemMetricData;
class="kw">import com.hypixel.hytale.component.query.ExactArchetypeQuery;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.system.ArchetypeChunkSystem;
class="kw">import com.hypixel.hytale.component.system.EcsEvent;
class="kw">import com.hypixel.hytale.component.system.EntityEventSystem;
class="kw">import com.hypixel.hytale.component.system.EntityHolderEventSystem;
class="kw">import com.hypixel.hytale.component.system.HolderSystem;
class="kw">import com.hypixel.hytale.component.system.ISystem;
class="kw">import com.hypixel.hytale.component.system.MetricSystem;
class="kw">import com.hypixel.hytale.component.system.QuerySystem;
class="kw">import com.hypixel.hytale.component.system.RefChangeSystem;
class="kw">import com.hypixel.hytale.component.system.RefSystem;
class="kw">import com.hypixel.hytale.component.system.StoreSystem;
class="kw">import com.hypixel.hytale.component.system.WorldEventSystem;
class="kw">import com.hypixel.hytale.component.system.data.ArchetypeDataSystem;
class="kw">import com.hypixel.hytale.component.system.data.EntityDataSystem;
class="kw">import com.hypixel.hytale.component.system.tick.ArchetypeTickingSystem;
class="kw">import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.component.system.tick.TickableSystem;
class="kw">import com.hypixel.hytale.component.system.tick.TickingSystem;
class="kw">import com.hypixel.hytale.component.task.ParallelRangeTask;
class="kw">import com.hypixel.hytale.component.task.ParallelTask;
class="kw">import com.hypixel.hytale.function.consumer.IntBiObjectConsumer;
class="kw">import com.hypixel.hytale.metrics.MetricResults;
class="kw">import com.hypixel.hytale.metrics.MetricsRegistry;
class="kw">import com.hypixel.hytale.metrics.metric.HistoricMetric;
class="kw">import it.unimi.dsi.fastutil.objects.Object2IntMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.lang.invoke.VarHandle;
class="kw">import java.util.ArrayDeque;
class="kw">import java.util.Arrays;
class="kw">import java.util.BitSet;
class="kw">import java.util.Collection;
class="kw">import java.util.Deque;
class="kw">import java.util.List;
class="kw">import java.util.Objects;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import java.util.concurrent.atomic.AtomicLong;
class="kw">import java.util.concurrent.locks.Condition;
class="kw">import java.util.concurrent.locks.Lock;
class="kw">import java.util.function.BiConsumer;
class="kw">import java.util.function.BiPredicate;
class="kw">import java.util.function.Predicate;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">public class Store<ECS_TYPE> class="kw">implements ComponentAccessor<ECS_TYPE> {
class="kw">public class="kw">static class="kw">final Store[] EMPTY_ARRAY = new Store[0];
class="kw">private class="kw">static class="kw">final boolean COUNT_SEQLOCK_RETRIES = Store.class.desiredAssertionStatus();
@Nonnull
class="kw">public class="kw">static class="kw">final MetricsRegistry<Store<?>> METRICS_REGISTRY = new MetricsRegistry<Store<?>>()
.register("ArchetypeChunkCount", Store::getArchetypeChunkCount, Codec.INTEGER)
.register("EntityCount", Store::getEntityCount, Codec.INTEGER)
.register(
"Systems",
var0 -> {
ComponentRegistry.Data var1 = var0.getRegistry().getData();
HistoricMetric[] var2 = var0.getSystemMetrics();
SystemMetricData[] var3 = new SystemMetricData[var1.getSystemSize()];
for (int var4 = 0; var4 < var1.getSystemSize(); var4++) {
ISystem var5 = var1.getSystem(var4);
MetricResults var6 = null;
if (var5 class="kw">instanceof MetricSystem var7) {
var6 = var7.toMetricResults(var0);
}
var3[var4] = new SystemMetricData(
var5.getClass().getName(),
var0.getArchetypeChunkCountFor(var4),
var0.getEntityCountFor(var4),
var5 class="kw">instanceof TickingSystem ? var2[var4] : null,
var6
);
}
class="kw">return var3;
},
new ArrayCodec<>(SystemMetricData.CODEC, SystemMetricData[]::new)
)
.register("ArchetypeChunks", Store::collectArchetypeChunkData, new ArrayCodec<>(ArchetypeChunkData.CODEC, ArchetypeChunkData[]::new));
@Nonnull
class="kw">private class="kw">final ComponentRegistry<ECS_TYPE> registry;
@Nonnull
class="kw">private class="kw">final ECS_TYPE externalData;
@Nonnull
class="kw">private class="kw">final IResourceStorage resourceStorage;
class="kw">private class="kw">final Deque<CommandBuffer<ECS_TYPE>> commandBuffers = new ArrayDeque<>();
class="kw">private class="kw">final Thread thread = Thread.currentThread();
@Nonnull
class="kw">private class="kw">final ParallelTask<EntityTickingSystem.SystemTaskData<ECS_TYPE>> parallelTask = new ParallelTask<>(EntityTickingSystem.SystemTaskData::new);
@Nonnull
class="kw">private class="kw">final ParallelTask<ForEachTaskData<ECS_TYPE>> forEachTask = new ParallelTask<>(ForEachTaskData::new);
@Nonnull
class="kw">private class="kw">final ParallelTask<EntityDataSystem.SystemTaskData<ECS_TYPE, ?, ?>> fetchTask = new ParallelTask<>(EntityDataSystem.SystemTaskData::new);
@Nonnull
class="kw">private class="kw">final Store.ProcessingCounter processing = new Store.ProcessingCounter();
class="kw">private class="kw">volatile boolean shutdown;
int storeIndex;
class="kw">private int entitiesSize;
@Nonnull
class="kw">private Ref<ECS_TYPE>[] refs = new Ref[16];
@Nonnull
class="kw">private BitSet[] systemIndexToArchetypeChunkIndexes = ArrayUtil.EMPTY_BITSET_ARRAY;
@Nonnull
class="kw">private class="kw">final Object2IntMap<Archetype<ECS_TYPE>> archetypeToIndexMap = new Object2IntOpenHashMap();
class="kw">private int archetypeSize;
@Nonnull
class="kw">private class="kw">final BitSet archetypeChunkReuse = new BitSet();
@Nonnull
class="kw">private ArchetypeChunk<ECS_TYPE>[] archetypeChunks = ArchetypeChunk.emptyArray();
@Nonnull
class="kw">private Resource<ECS_TYPE>[] resources = Resource.EMPTY_ARRAY;
@Nonnull
class="kw">private HistoricMetric[] systemMetrics = HistoricMetric.EMPTY_ARRAY;
@Deprecated(forRemoval = true)
class="kw">private boolean disableProcessingAssert = false;
@Nonnull
class="kw">final AtomicLong seqlockRetries = new AtomicLong();
Store(@Nonnull ComponentRegistry<ECS_TYPE> var1, int var2, @Nonnull ECS_TYPE var3, @Nonnull IResourceStorage var4) {
this.registry = var1;
this.storeIndex = var2;
this.externalData = var3;
this.resourceStorage = var4;
this.archetypeToIndexMap.defaultReturnValue(Integer.MIN_VALUE);
}
@Nonnull
CommandBuffer<ECS_TYPE> takeCommandBuffer() {
this.assertThread();
if (this.commandBuffers.isEmpty()) {
class="kw">return new CommandBuffer<>(this);
}
CommandBuffer var1 = this.commandBuffers.pop();
assert var1.setThread();
class="kw">return var1;
}
void storeCommandBuffer(@Nonnull CommandBuffer<ECS_TYPE> var1) {
this.assertThread();
var1.validateEmpty();
this.commandBuffers.add(var1);
}
class="kw">public int getStoreIndex() {
class="kw">return this.storeIndex;
}
@Nonnull
class="kw">public ComponentRegistry<ECS_TYPE> getRegistry() {
class="kw">return this.registry;
}
@Nonnull
@Override
class="kw">public ECS_TYPE getExternalData() {
class="kw">return this.externalData;
}
@Nonnull
class="kw">public IResourceStorage getResourceStorage() {
class="kw">return this.resourceStorage;
}
@Nonnull
class="kw">public ParallelTask<EntityTickingSystem.SystemTaskData<ECS_TYPE>> getParallelTask() {
class="kw">return this.parallelTask;
}
@Nonnull
class="kw">public ParallelTask<EntityDataSystem.SystemTaskData<ECS_TYPE, ?, ?>> getFetchTask() {
class="kw">return this.fetchTask;
}
@Nonnull
class="kw">public HistoricMetric[] getSystemMetrics() {
this.assertThread();
class="kw">return this.systemMetrics;
}
class="kw">public boolean isShutdown() {
class="kw">return this.shutdown;
}
void onAdd(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
this.updateArchetypeIndexes(var1);
int var2 = var1.getResourceSize();
this.resources = Arrays.copyOf(this.resources, var2);
for (int var3 = 0; var3 < var2; var3++) {
ResourceType var4 = (ResourceType<ECS_TYPE, ? class="kw">extends Resource<ECS_TYPE>>)var1.getResourceType(var3);
if (var4 != null) {
this.resources[var3] = (Resource<ECS_TYPE>)this.resourceStorage.load(this, var1, var4).join();
}
}
for (int var6 = 0; var6 < var1.getSystemSize(); var6++) {
this.updateData(var1, var1, new SystemChange<>(ChangeType.REGISTERED, var1.getSystem(var6)));
}
this.systemMetrics = Arrays.copyOf(this.systemMetrics, var1.getSystemSize());
SystemType var7 = this.registry.getTickableSystemType();
BitSet var8 = var1.getSystemIndexesForType(var7);
int var5 = -1;
while ((var5 = var8.nextSetBit(var5 + 1)) >= 0) {
this.systemMetrics[var5] = HistoricMetric.builder(33333333L, TimeUnit.NANOSECONDS)
.addPeriod(1L, TimeUnit.SECONDS)
.addPeriod(1L, TimeUnit.MINUTES)
.addPeriod(5L, TimeUnit.MINUTES)
.build();
}
}
class="kw">public void shutdown() {
if (this.shutdown) {
throw new IllegalStateException("Store is already shutdown!");
}
this.registry.removeStore(this);
}
void shutdown0(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
if (this.thread.isAlive() && this.thread != Thread.currentThread()) {
throw new IllegalArgumentException("Unable to shutdown store while thread is still running!");
}
for (int var2 = var1.getSystemSize() - 1; var2 >= 0; var2--) {
this.updateData(var1, var1, new SystemChange<>(ChangeType.UNREGISTERED, var1.getSystem(var2)));
}
this.saveAllResources0(var1).join();
this.processing.lock();
try {
for (int var6 = 0; var6 < this.entitiesSize; var6++) {
this.refs[var6].invalidate();
this.refs[var6] = null;
}
} class="kw">finally {
this.processing.unlock();
}
this.shutdown = true;
}
@Nonnull
class="kw">public CompletableFuture<Void> saveAllResources() {
class="kw">return this.saveAllResources0(this.registry.getData());
}
@Nonnull
class="kw">private CompletableFuture<Void> saveAllResources0(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
int var2 = var1.getResourceSize();
CompletableFuture[] var3 = new CompletableFuture[var2];
int var4 = 0;
for (int var5 = 0; var5 < var2; var5++) {
ResourceType var6 = (ResourceType<ECS_TYPE, ? class="kw">extends Resource<ECS_TYPE>>)var1.getResourceType(var5);
if (var6 != null) {
var3[var4++] = this.resourceStorage.save(this, var1, var6, this.resources[var5]);
}
}
class="kw">return CompletableFuture.allOf(Arrays.copyOf(var3, var4));
}
class="kw">public int getEntityCount() {
class="kw">return this.entitiesSize;
}
class="kw">public int getEntityCountFor(@Nonnull Query<ECS_TYPE> var1) {
this.assertThread();
if (var1 class="kw">instanceof ExactArchetypeQuery var2) {
int var6 = this.archetypeToIndexMap.getInt(var2.getArchetype());
class="kw">return var6 != Integer.MIN_VALUE ? this.archetypeChunks[var6].size() : 0;
} else {
int var3 = 0;
for (int var4 = 0; var4 < this.archetypeSize; var4++) {
ArchetypeChunk var5 = this.archetypeChunks[var4];
if (var5 != null && var1.test(var5.getArchetype())) {
var3 += var5.size();
}
}
class="kw">return var3;
}
}
class="kw">public int getEntityCountFor(int var1) {
this.assertThread();
int var2 = 0;
BitSet var3 = this.systemIndexToArchetypeChunkIndexes[var1];
int var4 = -1;
while ((var4 = var3.nextSetBit(var4 + 1)) >= 0) {
var2 += this.archetypeChunks[var4].size();
}
class="kw">return var2;
}
class="kw">public int getArchetypeChunkCount() {
this.assertThread();
class="kw">return this.archetypeSize;
}
@Nonnull
class="kw">public ArchetypeChunkData[] collectArchetypeChunkData() {
this.assertThread();
ObjectArrayList var1 = new ObjectArrayList(this.archetypeSize);
for (int var2 = 0; var2 < this.archetypeSize; var2++) {
ArchetypeChunk var3 = this.archetypeChunks[var2];
if (var3 != null) {
Archetype var4 = var3.getArchetype();
String[] var5 = new String[var4.count()];
int var6 = 0;
for (int var7 = var4.getMinIndex(); var7 < var4.length(); var7++) {
ComponentType var8 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)var4.get(var7);
if (var8 != null) {
var5[var6++] = var8.getTypeClass().getName();
}
}
var1.add(new ArchetypeChunkData(var5, var3.size()));
}
}
class="kw">return (ArchetypeChunkData[])var1.toArray(ArchetypeChunkData[]::new);
}
class="kw">public int getArchetypeChunkCountFor(int var1) {
this.assertThread();
class="kw">return this.systemIndexToArchetypeChunkIndexes[var1].cardinality();
}
@Nullable
class="kw">public Ref<ECS_TYPE> addEntity(@Nonnull Archetype<ECS_TYPE> var1, @Nonnull AddReason var2) {
this.assertThread();
this.assertWriteProcessing();
Component[] var3;
if (var1.isEmpty()) {
var3 = Component.EMPTY_ARRAY;
} else {
ComponentRegistry.Data var4 = this.registry._internal_getData();
var3 = new Component[var1.length()];
for (int var5 = var1.getMinIndex(); var5 < var1.length(); var5++) {
ComponentType var6 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)var1.get(var5);
if (var6 != null) {
var3[var6.getIndex()] = var4.createComponent((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var6);
}
}
}
class="kw">return this.addEntity(this.registry.newHolder(var1, var3), new Ref<>(this), var2);
}
@Nullable
@Override
class="kw">public Ref<ECS_TYPE> addEntity(@Nonnull Holder<ECS_TYPE> var1, @Nonnull AddReason var2) {
class="kw">return this.addEntity(var1, new Ref<>(this), var2);
}
@Nullable
class="kw">public Ref<ECS_TYPE> addEntity(@Nonnull Holder<ECS_TYPE> var1, @Nonnull Ref<ECS_TYPE> var2, @Nonnull AddReason var3) {
if (var2.isValid()) {
throw new IllegalArgumentException("EntityReference is already in use!");
}
if (var2.getStore() != this) {
throw new IllegalArgumentException("EntityReference is not for this store!");
}
this.assertThread();
this.assertWriteProcessing();
CommandBuffer var4 = this.takeCommandBuffer();
ComponentRegistry.Data var5 = this.registry._internal_getData();
this.processing.lock();
try {
SystemType var6 = this.registry.getHolderSystemType();
BitSet var7 = var5.getSystemIndexesForType(var6);
int var8 = -1;
while ((var8 = var7.nextSetBit(var8 + 1)) >= 0) {
HolderSystem var9 = var5.getSystem(var8, var6);
if (var9.test(this.registry, var1.getArchetype())) {
var9.onEntityAdd(var1, var3, this);
}
}
int var20 = this.entitiesSize++;
int var21 = this.refs.length;
if (var21 <= var20) {
var8 = ArrayUtil.grow(var20);
this.refs = Arrays.copyOf(this.refs, var8);
}
this.refs[var20] = var2;
var2.setIndex(var20);
var8 = this.findOrCreateArchetypeChunk(var1.getArchetype());
ArchetypeChunk var24 = this.archetypeChunks[var8];
int var10 = var24.addEntity(var2, var1);
var2.beginMutation();
var2.setPosition(var24, var10);
var2.endMutation();
SystemType systemTypex = this.registry.getRefSystemType();
BitSet systemIndexesx = var5.getSystemIndexesForType(systemTypex);
BitSet var13 = var24.getSystemIndexes();
var4.track(var2);
int systemIndexx = -1;
while ((systemIndexx = systemIndexesx.nextSetBit(systemIndexx + 1)) >= 0) {
if (var13.get(systemIndexx)) {
RefSystem var15 = var5.getSystem(systemIndexx, systemTypex);
boolean var16 = this.disableProcessingAssert;
this.disableProcessingAssert = var15 class="kw">instanceof DisableProcessingAssert;
var15.onEntityAdded(var2, var3, this, var4);
this.disableProcessingAssert = var16;
if (var4.consumeWasTrackedRefRemoved()) {
break;
}
}
}
} class="kw">finally {
this.processing.unlock();
}
var4.consume();
class="kw">return var2.isValid() ? var2 : null;
}
@Nonnull
@Override
class="kw">public Ref<ECS_TYPE>[] addEntities(@Nonnull Holder<ECS_TYPE>[] var1, @Nonnull AddReason var2) {
class="kw">return this.addEntities(var1, 0, var1.length, var2);
}
@Nonnull
class="kw">public Ref<ECS_TYPE>[] addEntities(@Nonnull Holder<ECS_TYPE>[] var1, int var2, int var3, @Nonnull AddReason var4) {
Ref[] var5 = new Ref[var3];
for (int var6 = 0; var6 < var3; var6++) {
var5[var6] = new Ref<>(this);
}
this.addEntities(var1, var2, var5, 0, var3, var4);
class="kw">return var5;
}
class="kw">public void addEntities(@Nonnull Holder<ECS_TYPE>[] var1, @Nonnull Ref<ECS_TYPE>[] var2, @Nonnull AddReason var3) {
if (var1.length != var2.length) {
throw new IllegalArgumentException("EntityHolder and EntityReference array length doesn't match!");
}
this.addEntities(var1, 0, var2, 0, var1.length, var3);
}
class="kw">public void addEntities(@Nonnull Holder<ECS_TYPE>[] var1, int var2, @Nonnull Ref<ECS_TYPE>[] var3, int var4, int var5, @Nonnull AddReason var6) {
int var7 = var2 + var5;
int var8 = var4 + var5;
if (var1.length < var7) {
throw new IllegalArgumentException("EntityHolder start and length exceed array length!");
}
if (var3.length < var8) {
throw new IllegalArgumentException("EntityReference start and length exceed array length!");
}
for (int var9 = var4; var9 < var8; var9++) {
Ref var10 = var3[var9];
if (var10.isValid()) {
throw new IllegalArgumentException("EntityReference is already in use!");
}
if (var10.getStore() != this) {
throw new IllegalArgumentException("EntityReference is not for this store!");
}
}
this.assertThread();
this.assertWriteProcessing();
CommandBuffer var25 = this.takeCommandBuffer();
ComponentRegistry.Data var26 = this.registry._internal_getData();
this.processing.lock();
try {
SystemType var11 = this.registry.getHolderSystemType();
BitSet var12 = var26.getSystemIndexesForType(var11);
int var13 = -1;
while ((var13 = var12.nextSetBit(var13 + 1)) >= 0) {
HolderSystem var14 = var26.getSystem(var13, var11);
for (int var15 = var2; var15 < var7; var15++) {
if (var14.test(this.registry, var1[var15].getArchetype())) {
var14.onEntityAdd(var1[var15], var6, this);
}
}
}
int var27 = this.entitiesSize;
this.entitiesSize += var5;
int var28 = this.refs.length;
if (var28 <= this.entitiesSize) {
var13 = ArrayUtil.grow(this.entitiesSize);
this.refs = Arrays.copyOf(this.refs, var13);
}
System.arraycopy(var3, var4, this.refs, var27, var5);
var13 = var4;
for (int var33 = var27; var13 < var8; var33++) {
var3[var13].setIndex(var33);
var13++;
}
var13 = 0;
for (int var34 = var27; var13 < var5; var34++) {
Ref var36 = var3[var4 + var13];
Holder var16 = var1[var2 + var13];
int var17 = this.findOrCreateArchetypeChunk(var16.getArchetype());
ArchetypeChunk var18 = this.archetypeChunks[var17];
int var19 = var18.addEntity(var36, var16);
var36.beginMutation();
var36.setPosition(var18, var19);
var36.endMutation();
var13++;
}
SystemType systemTypex = this.registry.getRefSystemType();
BitSet systemIndexesx = var26.getSystemIndexesForType(systemTypex);
int systemIndexx = -1;
while ((systemIndexx = systemIndexesx.nextSetBit(systemIndexx + 1)) >= 0) {
for (int var38 = var4; var38 < var8; var38++) {
Ref var39 = var3[var38];
BitSet var40 = var39.getArchetypeChunk().getSystemIndexes();
if (var40.get(systemIndexx)) {
RefSystem var41 = var26.getSystem(systemIndexx, systemTypex);
boolean var20 = this.disableProcessingAssert;
this.disableProcessingAssert = var41 class="kw">instanceof DisableProcessingAssert;
var25.track(var39);
var41.onEntityAdded(var39, var6, this, var25);
if (var25.consumeWasTrackedRefRemoved()) {
int var21 = var8 - var38;
if (var21 > 1) {
System.arraycopy(var3, var38 + 1, var3, var38, var21 - 1);
var3[var8 - 1] = var39;
var38--;
}
var8--;
var5--;
}
this.disableProcessingAssert = var20;
}
}
}
} class="kw">finally {
this.processing.unlock();
}
var25.consume();
}
@Nonnull
class="kw">public Holder<ECS_TYPE> copyEntity(@Nonnull Ref<ECS_TYPE> var1) {
class="kw">return this.copyEntity(var1, this.registry.newHolder());
}
@Nonnull
class="kw">public Holder<ECS_TYPE> copyEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Holder<ECS_TYPE> var2) {
this.assertThread();
var1.validate(this);
class="kw">return var1.getArchetypeChunk().copyEntity(var1.getChunkEntityIndex(), var2);
}
@Nonnull
class="kw">public Holder<ECS_TYPE> copySerializableEntity(@Nonnull Ref<ECS_TYPE> var1) {
class="kw">return this.copySerializableEntity(var1, this.registry.newHolder(), null);
}
@Nonnull
class="kw">public Holder<ECS_TYPE> copySerializableEntity(
@Nonnull Ref<ECS_TYPE> var1, @Nonnull Holder<ECS_TYPE> var2, @Nullable Predicate<ComponentType<ECS_TYPE, ?>> var3
) {
this.assertThread();
var1.validate(this);
class="kw">return var1.getArchetypeChunk().copySerializableEntity(this.registry.getData(), var1.getChunkEntityIndex(), var2, var3);
}
@Nonnull
@Override
class="kw">public Archetype<ECS_TYPE> getArchetype(@Nonnull Ref<ECS_TYPE> var1) {
this.assertThread();
var1.validate(this);
class="kw">return var1.getArchetypeChunk().getArchetype();
}
@Nonnull
class="kw">protected Archetype<ECS_TYPE> __internal_getArchetype(@Nonnull Ref<ECS_TYPE> var1) {
var1.validate(this);
class="kw">return var1.getArchetypeChunk().getArchetype();
}
@Nonnull
class="kw">public Holder<ECS_TYPE> removeEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull RemoveReason var2) {
class="kw">return this.removeEntity(var1, this.registry.newHolder(), var2);
}
@Nonnull
@Override
class="kw">public Holder<ECS_TYPE> removeEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Holder<ECS_TYPE> var2, @Nonnull RemoveReason var3) {
class="kw">return this.removeEntity(var1, var2, var3, null);
}
@Nonnull
Holder<ECS_TYPE> removeEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Holder<ECS_TYPE> var2, @Nonnull RemoveReason var3, @Nullable Throwable var4) {
this.assertThread();
this.assertWriteProcessing();
int var5 = var1.validate(this);
CommandBuffer var6 = this.takeCommandBuffer();
ArchetypeChunk var7 = var1.getArchetypeChunk();
int var8 = var1.getChunkEntityIndex();
ComponentRegistry.Data var9 = this.registry._internal_getData();
this.processing.lock();
try {
SystemType var10 = this.registry.getRefSystemType();
BitSet var11 = var9.getSystemIndexesForType(var10);
BitSet var12 = var7.getSystemIndexes();
int var13 = -1;
while ((var13 = var11.nextSetBit(var13 + 1)) >= 0) {
if (var12.get(var13)) {
var9.getSystem(var13, var10).onEntityRemove(var1, var3, this, var6);
}
}
int var22 = this.entitiesSize - 1;
if (var5 != var22) {
Ref var24 = this.refs[var22];
var24.setIndex(var5);
this.refs[var5] = var24;
}
this.refs[var22] = null;
this.entitiesSize = var22;
var1.beginMutation();
var7.removeEntity(var8, var2);
if (var7.size() == 0) {
this.removeArchetypeChunk(var7);
}
var1.invalidate(var4);
} class="kw">finally {
this.processing.unlock();
}
var6.consume();
this.processing.lock();
try {
SystemType var23 = this.registry.getHolderSystemType();
BitSet var25 = var9.getSystemIndexesForType(var23);
int var26 = -1;
while ((var26 = var25.nextSetBit(var26 + 1)) >= 0) {
HolderSystem var27 = var9.getSystem(var26, var23);
if (var27.test(this.registry, var2.getArchetype())) {
var27.onEntityRemoved(var2, var3, this);
}
}
} class="kw">finally {
this.processing.unlock();
}
class="kw">return var2;
}
@Nonnull
class="kw">public Holder<ECS_TYPE>[] removeEntities(@Nonnull Ref<ECS_TYPE>[] var1, @Nonnull RemoveReason var2) {
class="kw">return this.removeEntities(var1, 0, var1.length, var2);
}
@Nonnull
class="kw">public Holder<ECS_TYPE>[] removeEntities(@Nonnull Ref<ECS_TYPE>[] var1, int var2, int var3, @Nonnull RemoveReason var4) {
Holder[] var5 = new Holder[var3];
for (int var6 = 0; var6 < var3; var6++) {
var5[var6] = this.registry.newHolder();
}
class="kw">return this.removeEntities(var1, var2, var5, 0, var3, var4);
}
@Nonnull
class="kw">public Holder<ECS_TYPE>[] removeEntities(@Nonnull Ref<ECS_TYPE>[] var1, @Nonnull Holder<ECS_TYPE>[] var2, @Nonnull RemoveReason var3) {
if (var1.length != var2.length) {
throw new IllegalArgumentException("EntityHolder and EntityReference array length doesn't match!");
} else {
class="kw">return this.removeEntities(var1, 0, var2, 0, var1.length, var3);
}
}
@Nonnull
class="kw">public Holder<ECS_TYPE>[] removeEntities(
@Nonnull Ref<ECS_TYPE>[] var1, int var2, @Nonnull Holder<ECS_TYPE>[] var3, int var4, int var5, @Nonnull RemoveReason var6
) {
int var7 = var2 + var5;
int var8 = var4 + var5;
if (var1.length < var7) {
throw new IllegalArgumentException("EntityReference start and length exceed array length!");
}
if (var3.length < var8) {
throw new IllegalArgumentException("EntityHolder start and length exceed array length!");
}
for (int var9 = var2; var9 < var7; var9++) {
var1[var9].validate(this);
}
this.assertThread();
this.assertWriteProcessing();
CommandBuffer var26 = this.takeCommandBuffer();
ComponentRegistry.Data var10 = this.registry._internal_getData();
this.processing.lock();
try {
SystemType var11 = this.registry.getRefSystemType();
BitSet var12 = var10.getSystemIndexesForType(var11);
int var13 = -1;
while ((var13 = var12.nextSetBit(var13 + 1)) >= 0) {
for (int var14 = var2; var14 < var7; var14++) {
Ref var15 = var1[var14];
BitSet var16 = var15.getArchetypeChunk().getSystemIndexes();
if (var16.get(var13)) {
var10.getSystem(var13, var11).onEntityRemove(var1[var14], var6, this, var26);
}
}
}
for (int var27 = 0; var27 < var5; var27++) {
Ref var30 = var1[var2 + var27];
var13 = var30.getIndex();
ArchetypeChunk var34 = var30.getArchetypeChunk();
int var36 = var30.getChunkEntityIndex();
int var38 = this.entitiesSize - 1;
if (var13 != var38) {
Ref var17 = this.refs[var38];
var17.setIndex(var13);
this.refs[var13] = var17;
}
this.refs[var38] = null;
this.entitiesSize = var38;
Holder var39 = var3[var4 + var27];
var30.beginMutation();
var34.removeEntity(var36, var39);
if (var34.size() == 0) {
this.removeArchetypeChunk(var34);
}
}
for (int var28 = var2; var28 < var7; var28++) {
var1[var28].invalidate();
}
} class="kw">finally {
this.processing.unlock();
}
var26.consume();
this.processing.lock();
try {
SystemType var29 = this.registry.getHolderSystemType();
BitSet var31 = var10.getSystemIndexesForType(var29);
int var33 = -1;
while ((var33 = var31.nextSetBit(var33 + 1)) >= 0) {
HolderSystem var35 = var10.getSystem(var33, var29);
for (int var37 = var4; var37 < var8; var37++) {
if (var35.test(this.registry, var3[var37].getArchetype())) {
var35.onEntityRemoved(var3[var37], var6, this);
}
}
}
} class="kw">finally {
this.processing.unlock();
}
class="kw">return var3;
}
class="kw">public <T class="kw">extends Component<ECS_TYPE>> void ensureComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
this.assertThread();
this.assertWriteProcessing();
var2.validateRegistry(this.registry);
var2.validate();
CommandBuffer var3 = this.takeCommandBuffer();
this.processing.lock();
try {
ArchetypeChunk var4 = var1.getArchetypeChunk();
if (!var4.getArchetype().contains(var2)) {
Component var5 = this.registry._internal_getData().createComponent(var2);
this.datachunk_addComponent(var1, var4, var2, var5, var3);
}
} class="kw">finally {
this.processing.unlock();
}
var3.consume();
}
@Nonnull
@Override
class="kw">public <T class="kw">extends Component<ECS_TYPE>> T ensureAndGetComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
this.assertThread();
this.assertWriteProcessing();
var2.validateRegistry(this.registry);
var2.validate();
CommandBuffer var3 = this.takeCommandBuffer();
this.processing.lock();
Component var4;
try {
ArchetypeChunk var5 = var1.getArchetypeChunk();
var4 = var5.__internal_getComponent(var1.getChunkEntityIndex(), var2);
if (var4 == null) {
var4 = this.registry._internal_getData().createComponent(var2);
this.datachunk_addComponent(var1, var5, var2, var4, var3);
}
} class="kw">finally {
this.processing.unlock();
}
var3.consume();
class="kw">return var4;
}
@Nonnull
@Override
class="kw">public <T class="kw">extends Component<ECS_TYPE>> T addComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
this.assertThread();
this.assertWriteProcessing();
Component var3 = this.registry._internal_getData().createComponent(var2);
this.addComponent(var1, var2, var3);
class="kw">return var3;
}
@Override
class="kw">public <T class="kw">extends Component<ECS_TYPE>> void addComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2, @Nonnull T var3) {
this.assertThread();
this.assertWriteProcessing();
var1.validate(this);
var2.validateRegistry(this.registry);
var2.validate();
Objects.requireNonNull(var3);
CommandBuffer var4 = this.takeCommandBuffer();
this.processing.lock();
try {
this.datachunk_addComponent(var1, var1.getArchetypeChunk(), var2, var3, var4);
} class="kw">finally {
this.processing.unlock();
}
var4.consume();
}
class="kw">public <T class="kw">extends Component<ECS_TYPE>> void replaceComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2, @Nonnull T var3) {
this.assertThread();
this.assertWriteProcessing();
var1.validate(this);
var2.validateRegistry(this.registry);
var2.validate();
Objects.requireNonNull(var3);
CommandBuffer var4 = this.takeCommandBuffer();
this.processing.lock();
try {
ArchetypeChunk var5 = var1.getArchetypeChunk();
int var6 = var1.getChunkEntityIndex();
Component var7 = var5.__internal_getComponent(var6, var2);
var5.setComponent(var6, var2, var3);
BitSet var8 = var5.getSystemIndexes();
ComponentRegistry.Data var9 = this.registry._internal_getData();
BitSet var10 = var9.getSystemIndexesForType(this.registry.getRefChangeSystemType());
int var11 = -1;
while ((var11 = var10.nextSetBit(var11 + 1)) >= 0) {
if (var8.get(var11)) {
RefChangeSystem var12 = (RefChangeSystem<ECS_TYPE, T>)var9.getSystem(var11);
if (var12.componentType().getIndex() == var2.getIndex()) {
var12.onComponentSet(var1, var7, var3, this, var4);
}
}
}
} class="kw">finally {
this.processing.unlock();
}
var4.consume();
}
@Override
class="kw">public <T class="kw">extends Component<ECS_TYPE>> void putComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2, @Nonnull T var3) {
this.assertThread();
this.assertWriteProcessing();
var1.validate(this);
var2.validateRegistry(this.registry);
var2.validate();
Objects.requireNonNull(var3);
CommandBuffer var4 = this.takeCommandBuffer();
this.processing.lock();
try {
ArchetypeChunk var5 = var1.getArchetypeChunk();
if (var5.getArchetype().contains(var2)) {
int var6 = var1.getChunkEntityIndex();
Component var7 = var5.__internal_getComponent(var6, var2);
var5.setComponent(var6, var2, var3);
BitSet var8 = var5.getSystemIndexes();
ComponentRegistry.Data var9 = this.registry._internal_getData();
BitSet var10 = var9.getSystemIndexesForType(this.registry.getRefChangeSystemType());
int var11 = -1;
while ((var11 = var10.nextSetBit(var11 + 1)) >= 0) {
if (var8.get(var11)) {
RefChangeSystem var12 = (RefChangeSystem<ECS_TYPE, T>)var9.getSystem(var11);
if (var12.componentType().getIndex() == var2.getIndex()) {
var12.onComponentSet(var1, var7, var3, this, var4);
}
}
}
} else {
this.datachunk_addComponent(var1, var5, var2, var3, var4);
}
} class="kw">finally {
this.processing.unlock();
}
var4.consume();
}
@Override
class="kw">public <T class="kw">extends Component<ECS_TYPE>> T getComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
this.assertThread();
class="kw">return this.__internal_getComponent(var1, var2);
}
@Nullable
class="kw">public <T class="kw">extends Component<ECS_TYPE>> T getComponentConcurrent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
var2.validateRegistry(this.registry);
var2.validate();
while (true) {
int var3 = var1.getSeq();
if ((var3 & 1) != 0) {
Thread.onSpinWait();
} else {
if (!var1.isValid(this)) {
class="kw">return null;
}
ArchetypeChunk var4 = var1.getArchetypeChunk();
if (var4 == null) {
Thread.onSpinWait();
} else {
Component var5 = var4.__internal_getComponentConcurrent(var1.getChunkEntityIndex(), var2);
VarHandle.loadLoadFence();
if (var3 == var1.getSeq()) {
class="kw">return var5;
}
if (COUNT_SEQLOCK_RETRIES) {
this.seqlockRetries.incrementAndGet();
}
Thread.onSpinWait();
}
}
}
}
@Nullable
class="kw">protected <T class="kw">extends Component<ECS_TYPE>> T __internal_getComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
var1.validate(this);
var2.validateRegistry(this.registry);
var2.validate();
class="kw">return var1.getArchetypeChunk().__internal_getComponent(var1.getChunkEntityIndex(), var2);
}
@Override
class="kw">public <T class="kw">extends Component<ECS_TYPE>> void removeComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
this.assertThread();
this.assertWriteProcessing();
var1.validate(this);
var2.validateRegistry(this.registry);
var2.validate();
CommandBuffer var3 = this.takeCommandBuffer();
this.processing.lock();
try {
ArchetypeChunk var4 = var1.getArchetypeChunk();
int var5 = var1.getChunkEntityIndex();
Component var6 = var4.__internal_getComponent(var5, var2);
assert var6 != null;
Archetype var7 = Archetype.remove(var4.getArchetype(), var2);
int var8 = this.findOrCreateArchetypeChunk(var7);
ArchetypeChunk var9 = this.archetypeChunks[var8];
var9.addEntityFrom(var1, var4, var5);
BitSet var10 = var4.getSystemIndexes();
ComponentRegistry.Data var11 = this.registry._internal_getData();
BitSet var12 = var11.getSystemIndexesForType(this.registry.getRefChangeSystemType());
int var13 = -1;
while ((var13 = var12.nextSetBit(var13 + 1)) >= 0) {
if (var10.get(var13)) {
RefChangeSystem var14 = (RefChangeSystem<ECS_TYPE, T>)var11.getSystem(var13);
if (var14.componentType().getIndex() == var2.getIndex()) {
var14.onComponentRemoved(var1, var6, this, var3);
}
}
}
if (var4.size() == 0) {
this.removeArchetypeChunk(var4);
}
} class="kw">finally {
this.processing.unlock();
}
var3.consume();
}
@Override
class="kw">public <T class="kw">extends Component<ECS_TYPE>> void tryRemoveComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
this.removeComponentIfExists(var1, var2);
}
class="kw">public <T class="kw">extends Component<ECS_TYPE>> boolean removeComponentIfExists(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
this.assertThread();
this.assertWriteProcessing();
var1.validate(this);
var2.validateRegistry(this.registry);
var2.validate();
CommandBuffer var3 = this.takeCommandBuffer();
this.processing.lock();
boolean var4;
try {
ArchetypeChunk var5 = var1.getArchetypeChunk();
if (!var5.getArchetype().contains(var2)) {
var4 = false;
} else {
int var6 = var1.getChunkEntityIndex();
Component var7 = var5.__internal_getComponent(var6, var2);
assert var7 != null;
Archetype var8 = Archetype.remove(var5.getArchetype(), var2);
int var9 = this.findOrCreateArchetypeChunk(var8);
ArchetypeChunk var10 = this.archetypeChunks[var9];
var10.addEntityFrom(var1, var5, var6);
BitSet var11 = var5.getSystemIndexes();
ComponentRegistry.Data var12 = this.registry._internal_getData();
BitSet var13 = var12.getSystemIndexesForType(this.registry.getRefChangeSystemType());
int var14 = -1;
while ((var14 = var13.nextSetBit(var14 + 1)) >= 0) {
if (var11.get(var14)) {
RefChangeSystem var15 = (RefChangeSystem<ECS_TYPE, T>)var12.getSystem(var14);
if (var15.componentType().getIndex() == var2.getIndex()) {
var15.onComponentRemoved(var1, var7, this, var3);
}
}
}
if (var5.size() == 0) {
this.removeArchetypeChunk(var5);
}
var4 = true;
}
} class="kw">finally {
this.processing.unlock();
}
var3.consume();
class="kw">return var4;
}
class="kw">public <T class="kw">extends Resource<ECS_TYPE>> void replaceResource(@Nonnull ResourceType<ECS_TYPE, T> var1, @Nonnull T var2) {
this.assertThread();
var1.validateRegistry(this.registry);
Objects.requireNonNull(var2);
this.resources[var1.getIndex()] = var2;
}
@Nonnull
@Override
class="kw">public <T class="kw">extends Resource<ECS_TYPE>> T getResource(@Nonnull ResourceType<ECS_TYPE, T> var1) {
var1.validateRegistry(this.registry);
class="kw">return (T)this.resources[var1.getIndex()];
}
@Nonnull
class="kw">protected <T class="kw">extends Resource<ECS_TYPE>> T __internal_getResource(@Nonnull ResourceType<ECS_TYPE, T> var1) {
var1.validateRegistry(this.registry);
class="kw">return (T)this.resources[var1.getIndex()];
}
class="kw">public void forEachChunk(@Nonnull BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var1) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
CommandBuffer var2 = this.takeCommandBuffer();
this.processing.lock();
try {
for (int var3 = 0; var3 < this.archetypeSize; var3++) {
ArchetypeChunk var4 = this.archetypeChunks[var3];
if (var4 != null) {
var1.accept(var4, var2);
}
}
} class="kw">finally {
this.processing.unlock();
}
var2.consume();
}
class="kw">public boolean forEachChunk(@Nonnull BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var1) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
CommandBuffer var2 = this.takeCommandBuffer();
boolean var3 = false;
this.processing.lock();
try {
for (int var4 = 0; var4 < this.archetypeSize; var4++) {
ArchetypeChunk var5 = this.archetypeChunks[var4];
if (var5 != null && var1.test(var5, var2)) {
var3 = true;
break;
}
}
} class="kw">finally {
this.processing.unlock();
}
var2.consume();
class="kw">return var3;
}
class="kw">public void forEachChunk(Query<ECS_TYPE> var1, @Nonnull BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var2) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
CommandBuffer var3 = this.takeCommandBuffer();
this.processing.lock();
try {
if (var1 class="kw">instanceof ExactArchetypeQuery var4) {
int var5 = this.archetypeToIndexMap.getInt(var4.getArchetype());
if (var5 != Integer.MIN_VALUE) {
var2.accept(this.archetypeChunks[var5], var3);
}
} else {
for (int var10 = 0; var10 < this.archetypeSize; var10++) {
ArchetypeChunk var6 = this.archetypeChunks[var10];
if (var6 != null && var1.test(var6.getArchetype())) {
var2.accept(this.archetypeChunks[var10], var3);
}
}
}
} class="kw">finally {
this.processing.unlock();
}
var3.consume();
}
class="kw">public boolean forEachChunk(Query<ECS_TYPE> var1, @Nonnull BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var2) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
CommandBuffer var3 = this.takeCommandBuffer();
boolean var4 = false;
this.processing.lock();
try {
if (var1 class="kw">instanceof ExactArchetypeQuery var5) {
int var6 = this.archetypeToIndexMap.getInt(var5.getArchetype());
if (var6 != Integer.MIN_VALUE) {
var4 = var2.test(this.archetypeChunks[var6], var3);
}
} else {
for (int var11 = 0; var11 < this.archetypeSize; var11++) {
ArchetypeChunk var7 = this.archetypeChunks[var11];
if (var7 != null && var1.test(var7.getArchetype()) && var2.test(this.archetypeChunks[var11], var3)) {
var4 = true;
break;
}
}
}
} class="kw">finally {
this.processing.unlock();
}
var3.consume();
class="kw">return var4;
}
class="kw">public void forEachChunk(int var1, @Nonnull BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var2) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
CommandBuffer var3 = this.takeCommandBuffer();
this.processing.lock();
try {
BitSet var4 = this.systemIndexToArchetypeChunkIndexes[var1];
int var5 = -1;
while ((var5 = var4.nextSetBit(var5 + 1)) >= 0) {
var2.accept(this.archetypeChunks[var5], var3);
}
} class="kw">finally {
this.processing.unlock();
}
var3.consume();
}
class="kw">public boolean forEachChunk(int var1, @Nonnull BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var2) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
CommandBuffer var3 = this.takeCommandBuffer();
boolean var4 = false;
this.processing.lock();
try {
BitSet var5 = this.systemIndexToArchetypeChunkIndexes[var1];
int var6 = -1;
while ((var6 = var5.nextSetBit(var6 + 1)) >= 0) {
if (var2.test(this.archetypeChunks[var6], var3)) {
var4 = true;
break;
}
}
} class="kw">finally {
this.processing.unlock();
}
var3.consume();
class="kw">return var4;
}
class="kw">public void forEachEntityParallel(IntBiObjectConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var1) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
CommandBuffer var2 = this.takeCommandBuffer();
this.forEachTask.init();
this.processing.lock();
try {
for (int var3 = 0; var3 < this.archetypeSize; var3++) {
ArchetypeChunk var4 = this.archetypeChunks[var3];
if (var4 != null) {
int var5 = var4.size();
if (var5 != 0) {
ParallelRangeTask var6 = this.forEachTask.appendTask();
var6.init(0, var5);
int var7 = 0;
for (int var8 = var6.size(); var7 < var8; var7++) {
var6.get(var7).init(var1, var4, var2.fork());
}
}
}
}
ForEachTaskData.invokeParallelTask(this.forEachTask, var2);
} class="kw">finally {
this.processing.unlock();
}
var2.consume();
}
class="kw">public void forEachEntityParallel(Query<ECS_TYPE> var1, IntBiObjectConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var2) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
CommandBuffer var3 = this.takeCommandBuffer();
this.forEachTask.init();
this.processing.lock();
try {
if (var1 class="kw">instanceof ExactArchetypeQuery var4) {
int var14 = this.archetypeToIndexMap.getInt(var4.getArchetype());
if (var14 != Integer.MIN_VALUE) {
ArchetypeChunk var15 = this.archetypeChunks[var14];
int var16 = var15.size();
if (var16 != 0) {
ParallelRangeTask var17 = this.forEachTask.appendTask();
var17.init(0, var16);
int var18 = 0;
for (int var19 = var17.size(); var18 < var19; var18++) {
var17.get(var18).init(var2, var15, var3.fork());
}
}
}
} else {
for (int var5 = 0; var5 < this.archetypeSize; var5++) {
ArchetypeChunk var6 = this.archetypeChunks[var5];
if (var6 != null && var1.test(var6.getArchetype())) {
int var7 = var6.size();
if (var7 != 0) {
ParallelRangeTask var8 = this.forEachTask.appendTask();
var8.init(0, var7);
int var9 = 0;
for (int var10 = var8.size(); var9 < var10; var9++) {
var8.get(var9).init(var2, var6, var3.fork());
}
}
}
}
}
ForEachTaskData.invokeParallelTask(this.forEachTask, var3);
} class="kw">finally {
this.processing.unlock();
}
var3.consume();
}
class="kw">public <T class="kw">extends ArchetypeDataSystem<ECS_TYPE, Q, R>, Q, R> void fetch(@Nonnull SystemType<ECS_TYPE, T> var1, Q var2, @Nonnull List<R> var3) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
ComponentRegistry.Data var4 = this.registry._internal_getData();
CommandBuffer var5 = this.takeCommandBuffer();
this.fetchTask.init();
BitSet var6 = var4.getSystemIndexesForType(var1);
this.processing.lock();
try {
int var7 = -1;
while ((var7 = var6.nextSetBit(var7 + 1)) >= 0) {
ArchetypeDataSystem var8 = (T)var4.getSystem(var7, var1);
BitSet var9 = this.systemIndexToArchetypeChunkIndexes[var7];
int var10 = -1;
while ((var10 = var9.nextSetBit(var10 + 1)) >= 0) {
var8.fetch(this.archetypeChunks[var10], this, var5, var2, var3);
}
}
EntityDataSystem.SystemTaskData.invokeParallelTask(this.fetchTask, var5, var3);
} class="kw">finally {
this.processing.unlock();
}
var5.consume();
}
class="kw">public <T class="kw">extends EntityDataSystem<ECS_TYPE, Q, R>, Q, R> void fetch(
@Nonnull Collection<Ref<ECS_TYPE>> var1, @Nonnull SystemType<ECS_TYPE, T> var2, @Nonnull Q var3, @Nonnull List<R> var4
) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
ComponentRegistry.Data var5 = this.registry._internal_getData();
CommandBuffer var6 = this.takeCommandBuffer();
this.fetchTask.init();
BitSet var7 = var5.getSystemIndexesForType(var2);
this.processing.lock();
try {
int var8 = -1;
while ((var8 = var7.nextSetBit(var8 + 1)) >= 0) {
EntityDataSystem var9 = (T)var5.getSystem(var8, var2);
for (Ref var11 : var1) {
ArchetypeChunk var12 = var11.getArchetypeChunk();
BitSet var13 = var12.getSystemIndexes();
if (var13.get(var8)) {
var9.fetch(var11.getChunkEntityIndex(), var12, this, var6, var3, var4);
}
}
}
EntityDataSystem.SystemTaskData.invokeParallelTask(this.fetchTask, var6, var4);
} class="kw">finally {
this.processing.unlock();
}
var6.consume();
}
@Override
class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Event var2) {
EntityEventType var3 = this.registry.getEntityEventTypeForClass(var2.getClass());
if (var3 != null) {
((Store<ECS_TYPE>)this).invoke(var3, var1, var2);
}
}
@Override
class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull EntityEventType<ECS_TYPE, Event> var1, @Nonnull Ref<ECS_TYPE> var2, @Nonnull Event var3) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
ComponentRegistry.Data var4 = this.registry._internal_getData();
CommandBuffer var5 = this.takeCommandBuffer();
var5.track(var2);
BitSet var6 = var4.getSystemIndexesForType(var1);
this.processing.lock();
try {
ArchetypeChunk var7 = var2.getArchetypeChunk();
BitSet var8 = var7.getSystemIndexes();
int var9 = -1;
while ((var9 = var6.nextSetBit(var9 + 1)) >= 0) {
var9 = var8.nextSetBit(var9);
if (var9 < 0) {
break;
}
if (var6.get(var9)) {
EntityEventSystem var10 = var4.getSystem(var9, var1);
var10.handleInternal(var2.getChunkEntityIndex(), var7, this, var5, var3);
if (var5.consumeWasTrackedRefRemoved()) {
break;
}
}
}
} class="kw">finally {
this.processing.unlock();
}
var5.consume();
}
@Override
class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull Holder<ECS_TYPE> var1, @Nonnull Event var2) {
EntityHolderEventType var3 = this.registry.getEntityHolderEventTypeForClass(var2.getClass());
if (var3 != null) {
((Store<ECS_TYPE>)this).invoke(var3, var1, var2);
}
}
@Override
class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull EntityHolderEventType<ECS_TYPE, Event> var1, @Nonnull Holder<ECS_TYPE> var2, @Nonnull Event var3) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
ComponentRegistry.Data var4 = this.registry._internal_getData();
CommandBuffer var5 = this.takeCommandBuffer();
BitSet var6 = var4.getSystemIndexesForType(var1);
this.processing.lock();
try {
Archetype var7 = var2.getArchetype();
int var8 = -1;
while ((var8 = var6.nextSetBit(var8 + 1)) >= 0) {
EntityHolderEventSystem var9 = var4.getSystem(var8, var1);
if (var9.getQuery() != null && var9.getQuery().test(var7)) {
var9.handleInternal(var2, this, var5, var3);
}
}
} class="kw">finally {
this.processing.unlock();
}
var5.consume();
}
@Override
class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull Event var1) {
WorldEventType var2 = this.registry.getWorldEventTypeForClass(var1.getClass());
if (var2 != null) {
((Store<ECS_TYPE>)this).invoke(var2, var1);
}
}
@Override
class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull WorldEventType<ECS_TYPE, Event> var1, @Nonnull Event var2) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
ComponentRegistry.Data var3 = this.registry._internal_getData();
CommandBuffer var4 = this.takeCommandBuffer();
BitSet var5 = var3.getSystemIndexesForType(var1);
this.processing.lock();
try {
int var6 = -1;
while ((var6 = var5.nextSetBit(var6 + 1)) >= 0) {
WorldEventSystem var7 = var3.getSystem(var6, var1);
var7.handleInternal(this, var4, var2);
}
} class="kw">finally {
this.processing.unlock();
}
var4.consume();
}
class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(CommandBuffer<ECS_TYPE> var1, Ref<ECS_TYPE> var2, Event var3) {
EntityEventType var4 = this.registry.getEntityEventTypeForClass(var3.getClass());
if (var4 != null) {
((Store<ECS_TYPE>)this).internal_invoke(var1, var4, var2, var3);
}
}
class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(
CommandBuffer<ECS_TYPE> var1, @Nonnull EntityEventType<ECS_TYPE, Event> var2, Ref<ECS_TYPE> var3, Event var4
) {
ComponentRegistry.Data var5 = this.registry._internal_getData();
CommandBuffer var6 = var1.fork();
var6.track(var3);
BitSet var7 = var5.getSystemIndexesForType(var2);
ArchetypeChunk var8 = var3.getArchetypeChunk();
BitSet var9 = var8.getSystemIndexes();
int var10 = -1;
while ((var10 = var7.nextSetBit(var10 + 1)) >= 0) {
var10 = var9.nextSetBit(var10);
if (var10 < 0) {
break;
}
if (var7.get(var10)) {
EntityEventSystem var11 = var5.getSystem(var10, var2);
var11.handleInternal(var3.getChunkEntityIndex(), var8, this, var6, var4);
if (var6.consumeWasTrackedRefRemoved()) {
break;
}
}
}
var6.mergeParallel(var1);
}
class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(CommandBuffer<ECS_TYPE> var1, Holder<ECS_TYPE> var2, Event var3) {
EntityHolderEventType var4 = this.registry.getEntityHolderEventTypeForClass(var3.getClass());
if (var4 != null) {
((Store<ECS_TYPE>)this).internal_invoke(var1, var4, var2, var3);
}
}
class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(
CommandBuffer<ECS_TYPE> var1, @Nonnull EntityHolderEventType<ECS_TYPE, Event> var2, Holder<ECS_TYPE> var3, Event var4
) {
ComponentRegistry.Data var5 = this.registry._internal_getData();
BitSet var6 = var5.getSystemIndexesForType(var2);
Archetype var7 = var3.getArchetype();
int var8 = -1;
while ((var8 = var6.nextSetBit(var8 + 1)) >= 0) {
EntityHolderEventSystem var9 = var5.getSystem(var8, var2);
if (var9.getQuery() != null && var9.getQuery().test(var7)) {
var9.handleInternal(var3, this, var1, var4);
}
}
}
class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(CommandBuffer<ECS_TYPE> var1, Event var2) {
WorldEventType var3 = this.registry.getWorldEventTypeForClass(var2.getClass());
if (var3 != null) {
((Store<ECS_TYPE>)this).internal_invoke(var1, var3, var2);
}
}
class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(CommandBuffer<ECS_TYPE> var1, @Nonnull WorldEventType<ECS_TYPE, Event> var2, Event var3) {
ComponentRegistry.Data var4 = this.registry._internal_getData();
BitSet var5 = var4.getSystemIndexesForType(var2);
int var6 = -1;
while ((var6 = var5.nextSetBit(var6 + 1)) >= 0) {
WorldEventSystem var7 = var4.getSystem(var6, var2);
var7.handleInternal(this, var1, var3);
}
}
class="kw">public void tick(float var1) {
this.tickInternal(var1, this.registry.getTickingSystemType());
}
class="kw">public void pausedTick(float var1) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
this.tickInternal(var1, this.registry.getRunWhenPausedSystemType());
}
class="kw">private <Tickable class="kw">extends TickableSystem<ECS_TYPE>> void tickInternal(float var1, SystemType<ECS_TYPE, Tickable> var2) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
this.registry.getDataUpdateLock().readLock().lock();
try {
ComponentRegistry.Data var3 = this.registry.doDataUpdate();
BitSet var4 = var3.getSystemIndexesForType(var2);
int var5 = -1;
while ((var5 = var4.nextSetBit(var5 + 1)) >= 0) {
TickableSystem var6 = (Tickable)var3.getSystem(var5, var2);
long var7 = System.nanoTime();
var6.tick(var1, var5, this);
long var9 = System.nanoTime();
this.systemMetrics[var5].add(var9, var9 - var7);
}
} class="kw">finally {
this.registry.getDataUpdateLock().readLock().unlock();
}
}
class="kw">public void tick(ArchetypeTickingSystem<ECS_TYPE> var1, float var2, int var3) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
this.assertThread();
CommandBuffer var4 = this.takeCommandBuffer();
this.parallelTask.init();
boolean var5 = this.disableProcessingAssert;
this.disableProcessingAssert = var1 class="kw">instanceof DisableProcessingAssert;
this.processing.lock();
try {
BitSet var6 = this.systemIndexToArchetypeChunkIndexes[var3];
int var7 = -1;
while ((var7 = var6.nextSetBit(var7 + 1)) >= 0) {
var1.tick(var2, this.archetypeChunks[var7], this, var4);
}
EntityTickingSystem.SystemTaskData.invokeParallelTask(this.parallelTask, var4);
} class="kw">finally {
this.processing.unlock();
this.disableProcessingAssert = var5;
}
var4.consume();
}
void updateData(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1, @Nonnull ComponentRegistry.Data<ECS_TYPE> var2) {
if (this.shutdown) {
throw new IllegalStateException("Store is shutdown!");
}
int var3 = var2.getResourceSize();
this.resources = Arrays.copyOf(this.resources, var3);
for (int var4 = 0; var4 < this.resources.length; var4++) {
ResourceType var5 = (ResourceType<ECS_TYPE, ? class="kw">extends Resource<ECS_TYPE>>)var2.getResourceType(var4);
if (this.resources[var4] == null && var5 != null) {
this.resources[var4] = (Resource<ECS_TYPE>)this.resourceStorage.load(this, var2, var5).join();
} else if (this.resources[var4] != null && var5 == null) {
this.resources[var4] = null;
}
}
boolean var11 = false;
for (int var12 = 0; var12 < var2.getDataChangeCount(); var12++) {
DataChange var6 = var2.getDataChange(var12);
var11 |= var6 class="kw">instanceof SystemChange;
this.updateData(var1, var2, var6);
}
HistoricMetric[] var13 = this.systemMetrics;
this.systemMetrics = new HistoricMetric[var2.getSystemSize()];
SystemType var14 = this.registry.getTickableSystemType();
BitSet var7 = var2.getSystemIndexesForType(var14);
int var8 = -1;
while ((var8 = var7.nextSetBit(var8 + 1)) >= 0) {
ISystem var9 = var2.getSystem(var8);
int var10 = var1.indexOf(var9);
if (var10 >= 0) {
this.systemMetrics[var8] = var13[var10];
} else {
this.systemMetrics[var8] = HistoricMetric.builder(33333333L, TimeUnit.NANOSECONDS)
.addPeriod(1L, TimeUnit.SECONDS)
.addPeriod(1L, TimeUnit.MINUTES)
.addPeriod(5L, TimeUnit.MINUTES)
.build();
}
}
if (var11) {
this.updateArchetypeIndexes(var2);
}
}
class="kw">private void updateData(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1, @Nonnull ComponentRegistry.Data<ECS_TYPE> var2, DataChange var3) {
this.processing.lock();
try {
this.updateData0(var1, var2, var3);
} class="kw">finally {
this.processing.unlock();
}
if (var3 class="kw">instanceof SystemChange var4) {
ISystem var5 = var4.getSystem();
class="kw">switch (var4.getType()) {
case REGISTERED:
if (var5 class="kw">instanceof StoreSystem) {
((StoreSystem)var5).onSystemAddedToStore(this);
}
break;
case UNREGISTERED:
if (var5 class="kw">instanceof StoreSystem) {
((StoreSystem)var5).onSystemRemovedFromStore(this);
}
}
}
}
class="kw">private void updateData0(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1, @Nonnull ComponentRegistry.Data<ECS_TYPE> var2, DataChange var3) {
if (var3 class="kw">instanceof ComponentChange var4) {
ComponentType var5 = var4.getComponentType();
ComponentType var6 = this.registry.getUnknownComponentType();
class="kw">switch (var4.getType()) {
case REGISTERED:
String var22 = var2.getComponentId(var5);
Codec var25 = var2.getComponentCodec((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var5);
if (var25 != null) {
Holder var28 = this.registry._internal_newEntityHolder();
int var29 = this.archetypeSize;
for (int var31 = 0; var31 < var29; var31++) {
ArchetypeChunk var32 = this.archetypeChunks[var31];
if (var32 != null) {
Archetype var33 = var32.getArchetype();
if (!var33.contains(var5) && var33.contains(var6)) {
Archetype var35 = Archetype.add(var33, var5);
int var36 = this.findOrCreateArchetypeChunk(var35);
ArchetypeChunk var37 = this.archetypeChunks[var36];
var32.transferSomeTo(var28, var37, var3x -> {
UnknownComponents var4 = var32.getComponent(var3x, var6);
assert var4 != null;
class="kw">return var4.contains(var22);
}, var4x -> {
UnknownComponents var5 = var4x.getComponent(var6);
assert var5 != null;
Component var6 = var5.removeComponent(var22, var25);
var4x.addComponent(var5, var6);
}, (var1x, var2x) -> var2x.setPosition(var37, var1x));
if (var32.size() == 0) {
this.archetypeToIndexMap.removeInt(var32.getArchetype());
this.archetypeChunks[var31] = null;
for (int var17 = 0; var17 < var1.getSystemSize(); var17++) {
this.systemIndexToArchetypeChunkIndexes[var17].clear(var31);
}
var32.getSystemIndexes().clear();
this.archetypeChunkReuse.set(var31);
}
if (var37.size() == 0) {
this.archetypeToIndexMap.removeInt(var37.getArchetype());
this.archetypeChunks[var36] = null;
for (int var38 = 0; var38 < var1.getSystemSize(); var38++) {
this.systemIndexToArchetypeChunkIndexes[var38].clear(var36);
}
var37.getSystemIndexes().clear();
this.archetypeChunkReuse.set(var36);
}
}
}
}
}
break;
case UNREGISTERED:
Holder var9 = this.registry._internal_newEntityHolder();
String var7 = var1.getComponentId(var5);
Codec var8 = var1.getComponentCodec((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var5);
int var10 = this.archetypeSize;
for (int var11 = 0; var11 < var10; var11++) {
ArchetypeChunk var12 = this.archetypeChunks[var11];
if (var12 != null) {
Archetype var13 = var12.getArchetype();
if (var13.contains(var5)) {
this.archetypeToIndexMap.removeInt(var12.getArchetype());
this.archetypeChunks[var11] = null;
for (int var14 = 0; var14 < var1.getSystemSize(); var14++) {
this.systemIndexToArchetypeChunkIndexes[var14].clear(var11);
}
var12.getSystemIndexes().clear();
this.archetypeChunkReuse.set(var11);
Archetype var34 = Archetype.remove(var13, var5);
if (var8 != null && !var34.contains(var6)) {
var34 = Archetype.add(var34, var6);
}
int var15 = this.findOrCreateArchetypeChunk(var34);
ArchetypeChunk var16 = this.archetypeChunks[var15];
var12.transferTo(var9, var16, var4x -> {
if (var8 != null) {
UnknownComponents var5;
if (var4x.getArchetype().contains(var6)) {
var5 = var4x.getComponent(var6);
assert var5 != null;
} else {
var5 = new UnknownComponents<>();
var4x.addComponent(var6, var5);
}
Component var6 = var4x.getComponent((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var5);
var5.addComponent(var7, var6, var8);
}
var4x.removeComponent(var5);
}, (var1x, var2x) -> var2x.setPosition(var16, var1x));
}
}
}
int var30 = this.archetypeChunkReuse.previousClearBit(var10 - 1);
this.archetypeSize = var30 + 1;
this.archetypeChunkReuse.clear(this.archetypeSize, var10);
}
} else if (var3 class="kw">instanceof SystemChange var18) {
ISystem var19 = var18.getSystem();
class="kw">switch (var18.getType()) {
case REGISTERED:
if (var19 class="kw">instanceof ArchetypeChunkSystem var21) {
for (int var24 = 0; var24 < this.archetypeSize; var24++) {
ArchetypeChunk var27 = this.archetypeChunks[var24];
if (var27 != null && var21.test(this.registry, var27.getArchetype())) {
var21.onSystemAddedToArchetypeChunk(var27);
}
}
}
break;
case UNREGISTERED:
if (var19 class="kw">instanceof ArchetypeChunkSystem var20) {
for (int var23 = 0; var23 < this.archetypeSize; var23++) {
ArchetypeChunk var26 = this.archetypeChunks[var23];
if (var26 != null && var20.test(this.registry, var26.getArchetype())) {
var20.onSystemRemovedFromArchetypeChunk(var26);
}
}
}
}
}
}
class="kw">private void updateArchetypeIndexes(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
int var2 = var1.getSystemSize();
int var3 = this.systemIndexToArchetypeChunkIndexes.length;
if (var3 < var2) {
this.systemIndexToArchetypeChunkIndexes = Arrays.copyOf(this.systemIndexToArchetypeChunkIndexes, var2);
for (int var4 = var3; var4 < var2; var4++) {
this.systemIndexToArchetypeChunkIndexes[var4] = new BitSet(this.archetypeSize);
}
}
for (int var11 = 0; var11 < var3; var11++) {
this.systemIndexToArchetypeChunkIndexes[var11].clear();
}
for (int var12 = 0; var12 < this.archetypeSize; var12++) {
ArchetypeChunk var5 = this.archetypeChunks[var12];
if (var5 != null) {
var5.getSystemIndexes().clear();
}
}
SystemType var13 = this.registry.getQuerySystemType();
BitSet var14 = var1.getSystemIndexesForType(var13);
int var6 = -1;
while ((var6 = var14.nextSetBit(var6 + 1)) >= 0) {
QuerySystem var7 = var1.getSystem(var6, var13);
BitSet var8 = this.systemIndexToArchetypeChunkIndexes[var6];
for (int var9 = 0; var9 < this.archetypeSize; var9++) {
ArchetypeChunk var10 = this.archetypeChunks[var9];
if (var10 != null && var7.test(this.registry, var10.getArchetype())) {
var8.set(var9);
var10.getSystemIndexes().set(var6);
}
}
}
}
class="kw">public void assertWriteProcessing() {
if (this.processing.isHeld() && !this.disableProcessingAssert) {
throw new IllegalStateException("Store is currently processing! Ensure you aren't calling a store method from a system.");
}
}
@Deprecated
class="kw">public boolean isProcessing() {
class="kw">return this.processing.isHeld();
}
class="kw">public void assertThread() {
Thread var1 = Thread.currentThread();
if (var1 != this.thread && this.thread.isAlive()) {
throw new IllegalStateException("Assert not in thread! " + this.thread + " but was in " + var1);
}
}
class="kw">public boolean isInThread() {
class="kw">return Thread.currentThread() == this.thread;
}
class="kw">public boolean isAliveInDifferentThread() {
class="kw">return this.thread.isAlive() && Thread.currentThread() != this.thread;
}
@Nonnull
@Override
class="kw">public String toString() {
class="kw">return "Store{super()="
+ this.getClass()
+ "@"
+ this.hashCode()
+ ", registry="
+ this.registry.getClass()
+ "@"
+ this.registry.hashCode()
+ ", shutdown="
+ this.shutdown
+ ", storeIndex="
+ this.storeIndex
+ ", systemIndexToArchetypeChunkIndexes="
+ Arrays.toString(this.systemIndexToArchetypeChunkIndexes)
+ ", archetypeSize="
+ this.archetypeSize
+ ", archetypeChunks="
+ Arrays.toString(this.archetypeChunks)
+ "}";
}
class="kw">private <T class="kw">extends Component<ECS_TYPE>> void datachunk_addComponent(
@Nonnull Ref<ECS_TYPE> var1,
@Nonnull ArchetypeChunk<ECS_TYPE> var2,
@Nonnull ComponentType<ECS_TYPE, T> var3,
@Nonnull T var4,
@Nonnull CommandBuffer<ECS_TYPE> var5
) {
if (var2.getArchetype().contains(var3)) {
throw new IllegalArgumentException("Entity already contains component type: " + var3);
}
Archetype var6 = Archetype.add(var2.getArchetype(), var3);
int var7 = this.findOrCreateArchetypeChunk(var6);
ArchetypeChunk var8 = this.archetypeChunks[var7];
int var9 = var1.getChunkEntityIndex();
var8.addEntityFrom(var1, var2, var9, var3, var4);
BitSet var10 = var8.getSystemIndexes();
ComponentRegistry.Data var11 = this.registry._internal_getData();
BitSet var12 = var11.getSystemIndexesForType(this.registry.getRefChangeSystemType());
int var13 = -1;
while ((var13 = var12.nextSetBit(var13 + 1)) >= 0) {
if (var10.get(var13)) {
RefChangeSystem var14 = (RefChangeSystem<ECS_TYPE, T>)var11.getSystem(var13);
if (var14.componentType().getIndex() == var3.getIndex()) {
var14.onComponentAdded(var1, var4, this, var5);
}
}
}
if (var2.size() == 0) {
this.removeArchetypeChunk(var2);
}
}
class="kw">private int findOrCreateArchetypeChunk(@Nonnull Archetype<ECS_TYPE> var1) {
int var2 = this.archetypeToIndexMap.getInt(var1);
if (var2 != Integer.MIN_VALUE) {
class="kw">return var2;
}
ComponentRegistry.Data var3 = this.registry._internal_getData();
if (this.archetypeChunkReuse.isEmpty()) {
var2 = this.archetypeSize++;
} else {
var2 = this.archetypeChunkReuse.nextSetBit(0);
this.archetypeChunkReuse.clear(var2);
}
int var4 = this.archetypeChunks.length;
if (var4 <= var2) {
int var5 = ArrayUtil.grow(var2);
this.archetypeChunks = Arrays.copyOf(this.archetypeChunks, var5);
}
ArchetypeChunk var12 = new ArchetypeChunk<>(this, var1);
var12.setArchetypeIndex(var2);
this.archetypeChunks[var2] = var12;
this.archetypeToIndexMap.put(var1, var2);
BitSet var6 = var12.getSystemIndexes();
SystemType var7 = this.registry.getQuerySystemType();
BitSet var8 = var3.getSystemIndexesForType(var7);
int var9 = -1;
while ((var9 = var8.nextSetBit(var9 + 1)) >= 0) {
QuerySystem var10 = var3.getSystem(var9, var7);
if (var10.test(this.registry, var1)) {
this.systemIndexToArchetypeChunkIndexes[var9].set(var2);
var6.set(var9);
if (var10 class="kw">instanceof ArchetypeChunkSystem) {
((ArchetypeChunkSystem)var10).onSystemAddedToArchetypeChunk(var12);
}
}
}
class="kw">return var2;
}
class="kw">private void removeArchetypeChunk(@Nonnull ArchetypeChunk<ECS_TYPE> var1) {
int var2 = var1.getArchetypeIndex();
Archetype var3 = var1.getArchetype();
this.archetypeToIndexMap.removeInt(var3);
this.archetypeChunks[var2] = null;
var1.getSystemIndexes().clear();
ComponentRegistry.Data var4 = this.registry._internal_getData();
BitSet var5 = var4.getSystemIndexesForType(this.registry.getQuerySystemType());
int var6 = -1;
while ((var6 = var5.nextSetBit(var6 + 1)) >= 0) {
this.systemIndexToArchetypeChunkIndexes[var6].clear(var2);
if (var4.getSystem(var6) class="kw">instanceof ArchetypeChunkSystem var8 && var8.test(this.registry, var3)) {
var8.onSystemRemovedFromArchetypeChunk(var1);
}
}
if (var2 == this.archetypeSize - 1) {
int var9 = this.archetypeChunkReuse.previousClearBit(var2 - 1);
this.archetypeSize = var9 + 1;
this.archetypeChunkReuse.clear(this.archetypeSize, var2);
} else {
this.archetypeChunkReuse.set(var2);
}
}
class="kw">private class="kw">static class ProcessingCounter class="kw">implements Lock {
class="kw">private int count = 0;
class="kw">private ProcessingCounter() {
}
class="kw">public boolean isHeld() {
class="kw">return this.count > 0;
}
@Override
class="kw">public void lock() {
this.count++;
}
@Override
class="kw">public void lockInterruptibly() {
throw new UnsupportedOperationException("lockInterruptibly() is not supported");
}
@Override
class="kw">public boolean tryLock() {
throw new UnsupportedOperationException("tryLock() is not supported");
}
@Override
class="kw">public boolean tryLock(long var1, @Nonnull TimeUnit var3) {
throw new UnsupportedOperationException("tryLock() is not supported");
}
@Override
class="kw">public void unlock() {
this.count--;
}
@Nonnull
@Override
class="kw">public Condition newCondition() {
throw new UnsupportedOperationException("Conditions are not supported");
}
}
}