internal static unsafe bool CompareArray(ComponentType *type1, int typeCount1, ComponentType *type2, int typeCount2) { bool flag2; if (typeCount1 != typeCount2) { flag2 = false; } else { int index = 0; while (true) { if (index >= typeCount1) { flag2 = true; } else { if (!(type1[index] != type2[index])) { index++; continue; } flag2 = false; } break; } } return(flag2); }
public static bool CompareComponents(ComponentType *componentTypes, int componentTypesCount, EntityGroupData *groupData) { if (groupData->RequiredComponents == null) { return(false); } #if ENABLE_UNITY_COLLECTIONS_CHECKS for (var k = 0; k < componentTypesCount; ++k) { if (componentTypes[k].TypeIndex == TypeManager.GetTypeIndex <Entity>()) { throw new ArgumentException( "ComponentGroup.CompareComponents may not include typeof(Entity), it is implicit"); } } #endif // ComponentGroups are constructed including the Entity ID if (componentTypesCount + 1 != groupData->RequiredComponentsCount) { return(false); } for (var i = 0; i < componentTypesCount; ++i) { if (groupData->RequiredComponents[i + 1] != componentTypes[i]) { return(false); } } return(true); }
bool TestMatchingArchetypeAny(Archetype *archetype, ComponentType *anyTypes, int anyCount) { if (anyCount == 0) { return(true); } var componentTypes = archetype->Types; var componentTypesCount = archetype->TypesCount; for (var i = 0; i < componentTypesCount; i++) { var componentTypeIndex = componentTypes[i].TypeIndex; for (var j = 0; j < anyCount; j++) { var anyTypeIndex = anyTypes[j].TypeIndex; if (componentTypeIndex == anyTypeIndex) { return(true); } } } return(false); }
public static bool CompareComponents(ComponentType *componentTypes, int componentTypesCount, EntityQueryData *queryData) { #if ENABLE_UNITY_COLLECTIONS_CHECKS for (var k = 0; k < componentTypesCount; ++k) { if (componentTypes[k].TypeIndex == TypeManager.GetTypeIndex <Entity>()) { throw new ArgumentException( "EntityQuery.CompareComponents may not include typeof(Entity), it is implicit"); } } #endif var sortedTypes = stackalloc ComponentType[componentTypesCount]; for (var i = 0; i < componentTypesCount; ++i) { SortingUtilities.InsertSorted(sortedTypes, i, componentTypes[i]); } // EntityQueries are constructed including the Entity ID if (componentTypesCount + 1 != queryData->RequiredComponentsCount) { return(false); } for (var i = 0; i < componentTypesCount; ++i) { if (queryData->RequiredComponents[i + 1] != sortedTypes[i]) { return(false); } } return(true); }
// ---------------------------------------------------------------------------------------------------------- // INTERNAL // ---------------------------------------------------------------------------------------------------------- internal EntityArchetype CreateArchetype(ComponentType *types, int count) { ComponentTypeInArchetype *typesInArchetype = stackalloc ComponentTypeInArchetype[count + 1]; var cachedComponentCount = FillSortedArchetypeArray(typesInArchetype, types, count); // Lookup existing archetype (cheap) EntityArchetype entityArchetype; entityArchetype.Archetype = EntityComponentStore->GetExistingArchetype(typesInArchetype, cachedComponentCount); if (entityArchetype.Archetype != null) { return(entityArchetype); } // Creating an archetype invalidates all iterators / jobs etc // because it affects the live iteration linked lists... BeforeStructuralChange(); var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking(); entityArchetype.Archetype = EntityComponentStore->GetOrCreateArchetype(typesInArchetype, cachedComponentCount); var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges); EntityQueryManager.AddAdditionalArchetypes(changedArchetypes); return(entityArchetype); }
internal ComponentGroup GetComponentGroupInternal(ComponentType *componentTypes, int count) { for (var i = 0; i != m_ComponentGroups.Length; i++) { if (m_ComponentGroups[i].CompareComponents(componentTypes, count)) { return(m_ComponentGroups[i]); } } var group = EntityManager.CreateComponentGroup(componentTypes, count); group.SetFilterChangedRequiredVersion(m_LastSystemVersion); #if ENABLE_UNITY_COLLECTIONS_CHECKS group.DisallowDisposing = "ComponentGroup.Dispose() may not be called on a ComponentGroup created with ComponentSystem.GetComponentGroup. The ComponentGroup will automatically be disposed by the ComponentSystem."; #endif ArrayUtilityAdd(ref m_ComponentGroups, group); for (int i = 0; i != count; i++) { AddReaderWriter(componentTypes[i]); } //@TODO: Shouldn't this sync fence on the newly depent types? return(group); }
protected override void OnDestroyManager() { EndExclusiveEntityTransaction(); ComponentJobSafetyManager.PreDisposeCheck(); // Clean up all entities. This is needed to free all internal buffer allocations so memory is not leaked. using (var allEntities = GetAllEntities()) { DestroyEntity(allEntities); } ComponentJobSafetyManager.Dispose(); ComponentJobSafetyManager = null; Entities->OnDestroy(); UnsafeUtility.Free(Entities, Allocator.Persistent); Entities = null; ArchetypeManager.Dispose(); ArchetypeManager = null; m_GroupManager.Dispose(); m_GroupManager = null; m_ExclusiveEntityTransaction.OnDestroyManager(); m_SharedComponentManager.Dispose(); UnsafeUtility.Free(m_CachedComponentTypeArray, Allocator.Persistent); m_CachedComponentTypeArray = null; UnsafeUtility.Free(m_CachedComponentTypeInArchetypeArray, Allocator.Persistent); m_CachedComponentTypeInArchetypeArray = null; }
internal EntityArchetype CreateArchetype(ComponentType *types, int count) { ComponentTypeInArchetype *typesInArchetype = stackalloc ComponentTypeInArchetype[count + 1]; var cachedComponentCount = FillSortedArchetypeArray(typesInArchetype, types, count); // Lookup existing archetype (cheap) EntityArchetype entityArchetype; #if ENABLE_UNITY_COLLECTIONS_CHECKS entityArchetype._DebugComponentStore = EntityComponentStore; #endif entityArchetype.Archetype = EntityComponentStore->GetExistingArchetype(typesInArchetype, cachedComponentCount); if (entityArchetype.Archetype != null) { return(entityArchetype); } // Creating an archetype invalidates all iterators / jobs etc // because it affects the live iteration linked lists... EntityComponentStore.ArchetypeChanges archetypeChanges = default; if (m_IsMainThread) { BeforeStructuralChange(); } archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking(); entityArchetype.Archetype = EntityComponentStore->GetOrCreateArchetype(typesInArchetype, cachedComponentCount); EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges, EntityQueryManager); return(entityArchetype); }
unsafe public static Entity Instantiate(this EntityManager entityManager, GameObject srcGameObject) { if (entityManager.m_CachedComponentList == null) { entityManager.m_CachedComponentList = new List <ComponentDataWrapperBase>(); } var components = (List <ComponentDataWrapperBase>)entityManager.m_CachedComponentList; srcGameObject.GetComponents(components); var count = components.Count; ComponentType *componentTypes = stackalloc ComponentType[count]; for (var t = 0; t != count; ++t) { componentTypes[t] = components[t].GetComponentType(); } var srcEntity = entityManager.CreateEntity(entityManager.CreateArchetype(componentTypes, count)); for (var t = 0; t != count; ++t) { components[t].UpdateComponentData(entityManager, srcEntity); } return(srcEntity); }
public ComponentGroup CreateEntityGroup(ArchetypeManager typeMan, EntityDataManager *entityDataManager, ArchetypeQuery *archetypeQueries, int archetypeFiltersCount, ComponentType *requiredComponents, int requiredComponentsCount) { //@TODO: Validate that required types is subset of archetype filters all... var grp = (EntityGroupData *)m_GroupDataChunkAllocator.Allocate(sizeof(EntityGroupData), 8); grp->PrevGroup = m_LastGroupData; m_LastGroupData = grp; grp->RequiredComponentsCount = requiredComponentsCount; grp->RequiredComponents = requiredComponents; InitializeReaderWriter(grp, requiredComponents, requiredComponentsCount); grp->ArchetypeQuery = archetypeQueries; grp->ArchetypeQueryCount = archetypeFiltersCount; grp->FirstMatchingArchetype = null; grp->LastMatchingArchetype = null; for (var i = typeMan.m_Archetypes.Count - 1; i >= 0; --i) { var archetype = typeMan.m_Archetypes.p[i]; AddArchetypeIfMatching(archetype, grp); } return(new ComponentGroup(grp, m_JobSafetyManager, typeMan, entityDataManager)); }
public EntityQuery CreateEntityQuery(EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore, ArchetypeQuery *query, int queryCount, ComponentType *component, int componentCount) { //@TODO: Validate that required types is subset of archetype filters all... int hash = (int)math.hash(component, componentCount * sizeof(ComponentType)); for (var i = 0; i < queryCount; ++i) { hash = hash * 397 ^ query[i].GetHashCode(); } EntityQueryData *cachedQuery = null; if (m_EntityGroupDataCache.TryGetFirstValue(hash, out var entityGroupDataIndex, out var iterator)) { do { var possibleMatch = m_EntityGroupDatas.Ptr[entityGroupDataIndex]; if (Matches(possibleMatch, query, queryCount, component, componentCount)) { cachedQuery = possibleMatch; break; } } while (m_EntityGroupDataCache.TryGetNextValue(out entityGroupDataIndex, ref iterator)); } if (cachedQuery == null) { cachedQuery = (EntityQueryData *)ChunkAllocate <EntityQueryData>(); cachedQuery->RequiredComponentsCount = componentCount; cachedQuery->RequiredComponents = (ComponentType *)ChunkAllocate <ComponentType>(componentCount, component); InitializeReaderWriter(cachedQuery, component, componentCount); cachedQuery->ArchetypeQueryCount = queryCount; cachedQuery->ArchetypeQuery = (ArchetypeQuery *)ChunkAllocate <ArchetypeQuery>(queryCount, query); for (var i = 0; i < queryCount; ++i) { cachedQuery->ArchetypeQuery[i].All = (int *)ChunkAllocate <int>(cachedQuery->ArchetypeQuery[i].AllCount, query[i].All); cachedQuery->ArchetypeQuery[i].Any = (int *)ChunkAllocate <int>(cachedQuery->ArchetypeQuery[i].AnyCount, query[i].Any); cachedQuery->ArchetypeQuery[i].None = (int *)ChunkAllocate <int>(cachedQuery->ArchetypeQuery[i].NoneCount, query[i].None); cachedQuery->ArchetypeQuery[i].AllAccessMode = (byte *)ChunkAllocate <byte>(cachedQuery->ArchetypeQuery[i].AllCount, query[i].AllAccessMode); cachedQuery->ArchetypeQuery[i].AnyAccessMode = (byte *)ChunkAllocate <byte>(cachedQuery->ArchetypeQuery[i].AnyCount, query[i].AnyAccessMode); cachedQuery->ArchetypeQuery[i].NoneAccessMode = (byte *)ChunkAllocate <byte>(cachedQuery->ArchetypeQuery[i].NoneCount, query[i].NoneAccessMode); } cachedQuery->MatchingArchetypes = new UnsafeMatchingArchetypePtrList(entityComponentStore); cachedQuery->EntityQueryMask = new EntityQueryMask(); for (var i = 0; i < entityComponentStore->m_Archetypes.Length; ++i) { var archetype = entityComponentStore->m_Archetypes.Ptr[i]; AddArchetypeIfMatching(archetype, cachedQuery); } m_EntityGroupDataCache.Add(hash, m_EntityGroupDatas.Length); m_EntityGroupDatas.Add(cachedQuery); } return(new EntityQuery(cachedQuery, m_JobSafetyManager, entityComponentStore, managedComponentStore)); }
public static void Burst_Unity__Entities__EntityDataAccess_FillSortedArchetypeArray(IntPtr p) { ComponentTypeInArchetype *v0 = (ComponentTypeInArchetype *)((byte *)p + 0); ComponentType * v1 = (ComponentType *)((byte *)p + 1024); var v2 = default(int); EntityDataAccess.FillSortedArchetypeArray(v0, v1, v2); }
public static void Burst_Unity__Entities__EntityDataAccess_CreateArchetype(IntPtr p) { ComponentType *v0 = (ComponentType *)((byte *)p + 0); var v1 = default(int); var instance = (EntityDataAccess *)p; instance->CreateArchetype(v0, v1); }
public static unsafe void InsertSorted(ComponentType *data, int length, ComponentType newValue) { while (length > 0 && newValue < data[length - 1]) { data[length] = data[length - 1]; --length; } data[length] = newValue; }
private int PopulatedCachedTypeInArchetypeArray(ComponentType *requiredComponents, int count) { m_CachedComponentTypeInArchetypeArray[0] = new ComponentTypeInArchetype(ComponentType.Create <Entity>()); for (var i = 0; i < count; ++i) { SortingUtilities.InsertSorted(m_CachedComponentTypeInArchetypeArray, i + 1, requiredComponents[i]); } return(count + 1); }
private unsafe bool TestMatchingArchetypeAll(Archetype *archetype, ComponentType *allTypes, int allCount) { ComponentTypeInArchetype *types = archetype.Types; int typesCount = archetype.TypesCount; int num2 = 0; int typeIndex = TypeManager.GetTypeIndex <Disabled>(); int num4 = TypeManager.GetTypeIndex <Prefab>(); bool flag = false; bool flag2 = false; int index = 0; while (true) { if (index >= typesCount) { bool flag9; if (archetype.Disabled && !flag) { flag9 = false; } else if (archetype.Prefab && !flag2) { flag9 = false; } else { flag9 = num2 == allCount; } return(flag9); } int num6 = types[index].TypeIndex; int num7 = 0; while (true) { if (num7 >= allCount) { index++; break; } int num8 = allTypes[num7].TypeIndex; if (num8 == typeIndex) { flag = true; } if (num8 == num4) { flag2 = true; } if (num6 == num8) { num2++; } num7++; } } }
public static bool CompareComponents(ComponentType *componentTypes, int componentTypesCount, EntityQueryData *queryData) { #if ENABLE_UNITY_COLLECTIONS_CHECKS for (var k = 0; k < componentTypesCount; ++k) { if (componentTypes[k].TypeIndex == TypeManager.GetTypeIndex <Entity>()) { throw new ArgumentException( "EntityQuery.CompareComponents may not include typeof(Entity), it is implicit"); } } #endif if ((queryData->ArchetypeQueryCount != 1) || // This code path only matches one archetypequery (queryData->ArchetypeQuery[0].Options != EntityQueryOptions.Default)) // This code path does not allow query options { return(false); } var sortedTypes = stackalloc ComponentType[componentTypesCount]; for (var i = 0; i < componentTypesCount; ++i) { SortingUtilities.InsertSorted(sortedTypes, i, componentTypes[i]); } ConvertComponentListToSortedIntListsNoAlloc(sortedTypes, componentTypesCount, out var componentCompareQuery); var includeCount = componentCompareQuery.includeTypeIndices.Length; var excludeCount = componentCompareQuery.excludeTypeIndices.Length; var archetypeQuery = queryData->ArchetypeQuery[0]; if ((includeCount != archetypeQuery.AllCount) || (excludeCount != archetypeQuery.NoneCount)) { return(false); } for (int i = 0; i < includeCount; ++i) { if (componentCompareQuery.includeTypeIndices[i] != archetypeQuery.All[i] || componentCompareQuery.includeAccessModes[i] != archetypeQuery.AllAccessMode[i]) { return(false); } } for (int i = 0; i < excludeCount; ++i) { if (componentCompareQuery.excludeTypeIndices[i] != archetypeQuery.None[i] || componentCompareQuery.excludeAccessModes[i] != archetypeQuery.NoneAccessMode[i]) { return(false); } } return(true); }
internal unsafe EntityArchetype CreateArchetype(ComponentType *types, int count) { EntityArchetype archetype; this.CheckAccess(); EntityGroupManager target = (EntityGroupManager)this.m_EntityGroupManager.Target; archetype.Archetype = this.ArchetypeManager.GetOrCreateArchetype(this.m_CachedComponentTypeInArchetypeArray, this.PopulatedCachedTypeInArchetypeArray(types, count), target); return(archetype); }
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { if (disposing && Native != null) { Native.Destruct(); _ctype = null; } base.Dispose(disposing); }
internal EntityArchetype CreateArchetypeRaw(int *typeIndices, int count) { // TODO fix this up ComponentType *ct = stackalloc ComponentType[count]; for (int i = 0; i < count; ++i) { ct[i] = ComponentType.FromTypeIndex(typeIndices[i]); } return(CreateArchetype(ct, count)); }
void CreateRequiredComponents(ComponentType *requiredComponents, int requiredComponentsCount, out ComponentType *types, out int typesCount) { types = (ComponentType *)m_GroupDataChunkAllocator.Allocate(sizeof(ComponentType) * (requiredComponentsCount + 1), UnsafeUtility.AlignOf <ComponentType>()); types[0] = ComponentType.Create <Entity>(); for (int i = 0; i != requiredComponentsCount; i++) { types[i + 1] = requiredComponents[i]; } typesCount = requiredComponentsCount + 1; }
private unsafe bool TestMatchingArchetypeAny(Archetype *archetype, ComponentType *anyTypes, int anyCount) { ComponentTypeInArchetype *types; int typesCount; int num2; if (anyCount != 0) { types = archetype.Types; typesCount = archetype.TypesCount; num2 = 0; } else { return(true); } while (true) { while (true) { bool flag2; if (num2 < typesCount) { int typeIndex = types[num2].TypeIndex; int index = 0; while (true) { if (index < anyCount) { int num5 = anyTypes[index].TypeIndex; if (typeIndex != num5) { index++; continue; } flag2 = true; } else { num2++; continue; } break; } } else { flag2 = false; } return(flag2); } } }
void InitializeReaderWriter(EntityQueryData *grp, ComponentType *requiredTypes, int requiredCount) { Assert.IsTrue(requiredCount > 0); Assert.IsTrue(requiredTypes[0] == ComponentType.ReadWrite <Entity>()); grp->ReaderTypesCount = 0; grp->WriterTypesCount = 0; for (var i = 1; i != requiredCount; i++) { // After the first zero sized component the rest are zero sized if (requiredTypes[i].IsZeroSized) { break; } switch (requiredTypes[i].AccessModeType) { case ComponentType.AccessMode.ReadOnly: grp->ReaderTypesCount++; break; default: grp->WriterTypesCount++; break; } } grp->ReaderTypes = (int *)m_GroupDataChunkAllocator.Allocate(sizeof(int) * grp->ReaderTypesCount, 4); grp->WriterTypes = (int *)m_GroupDataChunkAllocator.Allocate(sizeof(int) * grp->WriterTypesCount, 4); var curReader = 0; var curWriter = 0; for (var i = 1; i != requiredCount; i++) { if (requiredTypes[i].IsZeroSized) { break; } switch (requiredTypes[i].AccessModeType) { case ComponentType.AccessMode.ReadOnly: grp->ReaderTypes[curReader++] = requiredTypes[i].TypeIndex; break; default: grp->WriterTypes[curWriter++] = requiredTypes[i].TypeIndex; break; } } }
internal EntityArchetype CreateArchetype(ComponentType *types, int count) { CheckAccess(); var groupManager = (EntityGroupManager)m_EntityGroupManager.Target; EntityArchetype type; type.Archetype = ArchetypeManager.GetOrCreateArchetype(m_CachedComponentTypeInArchetypeArray, PopulatedCachedTypeInArchetypeArray(types, count), groupManager); return(type); }
private unsafe int PopulatedCachedTypeInArchetypeArray(ComponentType *requiredComponents, int count) { if ((count + 1) > 0x400) { throw new ArgumentException($"Archetypes can't hold more than {0x400}"); } this.m_CachedComponentTypeInArchetypeArray[0] = new ComponentTypeInArchetype(ComponentType.Create <Entity>()); for (int i = 0; i < count; i++) { SortingUtilities.InsertSorted(this.m_CachedComponentTypeInArchetypeArray, i + 1, requiredComponents[i]); } return(count + 1); }
internal EntityArchetype CreateArchetype(ComponentType *types, int count) { CheckAccess(); ComponentTypeInArchetype *typesInArchetype = stackalloc ComponentTypeInArchetype[count + 1]; var componentCount = EntityManager.FillSortedArchetypeArray(typesInArchetype, types, count); EntityArchetype type; type.Archetype = EntityManagerCreateArchetypeUtility.GetOrCreateArchetype(typesInArchetype, componentCount, EntityComponentStore); return(type); }
public static unsafe void InsertSorted(ComponentType *data, int length, ComponentType newValue) { while (true) { if ((length <= 0) || (newValue >= data[length - 1])) { data[length] = newValue; return; } data[length] = data[length - 1]; length--; } }
public static unsafe bool GetComponents(this GameObject @this, ComponentType *componentTypes, int maxComponentTypes, List <Component> componentsCache) { int outputIndex = 0; @this.GetComponents(componentsCache); if (maxComponentTypes < componentsCache.Count) { LogWarning($"Too many components on {@this.name}", @this); return(false); } for (var i = 0; i != componentsCache.Count; i++) { var component = componentsCache[i]; if (component == null) { LogWarning($"The referenced script is missing on {@this.name}", @this); } else if (!component.IsComponentDisabled() && !(component is GameObjectEntity)) { #pragma warning disable 618 // remove once ComponentDataProxyBase is removed var componentType = (component as ComponentDataProxyBase)?.GetComponentType() ?? component.GetType(); #pragma warning restore 618 var isUniqueType = true; for (var j = 0; j < outputIndex; ++j) { if (componentTypes[j].Equals(componentType)) { isUniqueType = false; break; } } if (!isUniqueType) { continue; } componentsCache[outputIndex] = component; componentTypes[outputIndex] = componentType; outputIndex++; } } componentsCache.RemoveRange(outputIndex, componentsCache.Count - outputIndex); return(true); }
public ComponentGroup CreateComponentGroup(ComponentType *requiredComponents, int count) { var typeArrayCount = PopulatedCachedTypeArray(requiredComponents, count); var grp = m_GroupManager.CreateEntityGroupIfCached(m_ArchetypeManager, m_Entities, m_CachedComponentTypeArray, typeArrayCount); if (grp != null) { return(grp); } BeforeStructuralChange(); return(m_GroupManager.CreateEntityGroup(m_ArchetypeManager, m_Entities, m_CachedComponentTypeArray, typeArrayCount)); }
public ComponentGroup CreateEntityGroupIfCached(ArchetypeManager typeMan, EntityDataManager *entityDataManager, ComponentType *requiredTypes, int requiredCount) { var hash = HashUtility.Fletcher32((ushort *)requiredTypes, requiredCount * sizeof(ComponentType) / sizeof(short)); var grp = GetCachedGroupData(hash, requiredTypes, requiredCount); if (grp != null) { return(new ComponentGroup(grp, m_JobSafetyManager, typeMan, entityDataManager)); } return(null); }
void InitializeReaderWriter(EntityGroupData *grp, ComponentType *requiredTypes, int requiredCount) { grp->ReaderTypesCount = 0; grp->WriterTypesCount = 0; for (var i = 0; i != requiredCount; i++) { //@TODO: Investigate why Entity is not early out on this one... if (!requiredTypes[i].RequiresJobDependency) { continue; } switch (requiredTypes[i].AccessModeType) { case ComponentType.AccessMode.ReadOnly: grp->ReaderTypesCount++; break; default: grp->WriterTypesCount++; break; } } grp->ReaderTypes = (int *)m_GroupDataChunkAllocator.Allocate(sizeof(int) * grp->ReaderTypesCount, 4); grp->WriterTypes = (int *)m_GroupDataChunkAllocator.Allocate(sizeof(int) * grp->WriterTypesCount, 4); var curReader = 0; var curWriter = 0; for (var i = 0; i != requiredCount; i++) { if (!requiredTypes[i].RequiresJobDependency) { continue; } switch (requiredTypes[i].AccessModeType) { case ComponentType.AccessMode.ReadOnly: grp->ReaderTypes[curReader++] = requiredTypes[i].TypeIndex; break; default: grp->WriterTypes[curWriter++] = requiredTypes[i].TypeIndex; break; } } }
/// <summary> /// Initializes the specified descriptor. /// </summary> /// <param name="descriptor">The descriptor.</param> protected void Initialize(ComponentDescriptor descriptor) { _ctype = descriptor.Ctype; }