// CSComponents can be instantiated from a serialized scene or from within managed code protected CSComponent() { if (nativeLoadOverrideValidate != IntPtr.Zero) { // When loading CSComponents from a scene, many issues circumvented by not allowing additional components // to be created (on the Node) during serialization, so this is an error state throw new InvalidOperationException($"CSComponent() - Recursive CSComponent instantiation in default constructor during load type: { GetType().Name} "); } // detect instantiation type InstantiationType itype = InstantiationType.INSTANTIATION_NATIVE; IntPtr ninstance = IntPtr.Zero; if (nativeLoadOverride == IntPtr.Zero) { // We are being "new'd" in managed code ninstance = csi_Atomic_CSComponent_Constructor(); itype = InstantiationType.INSTANTIATION_NET; } else { // We are loading from a serialized CSComponent ninstance = nativeInstance = nativeLoadOverride; // validation bookkeeping nativeLoadOverrideValidate = nativeLoadOverride; nativeLoadOverride = IntPtr.Zero; } NativeCore.RegisterNative(ninstance, this, itype); }
// register a newly created native public static IntPtr RegisterNative(IntPtr native, RefCounted r, InstantiationType instantiationType = InstantiationType.INSTANTIATION_NET) { if (native == IntPtr.Zero || r == null) { throw new InvalidOperationException("NativeCore.RegisterNative - native == IntPtr.Zero || RefCounted instance == null"); } if (instantiationType == InstantiationType.INSTANTIATION_NET) { if (r.nativeInstance != IntPtr.Zero) { throw new InvalidOperationException("NativeCore.RegisterNative - NET Instantiated RefCounted with initialized nativeInstance"); } r.nativeInstance = native; } r.InstantiationType = instantiationType; r.InternalInit(); refCountedCache.Add(r); r.PostNativeUpdate(); return(native); }
public static TypeMapping Create <TFrom, TTo>(string key, InstantiationType instantiate) where TTo : TFrom { return(new TypeMapping(typeof(TFrom), typeof(TTo), key) { InstantiationType = instantiate }); }
public virtual void RegisterTypeMapping <TFrom, TTo>(string key, InstantiationType instantiationType) where TTo : TFrom { var typeMappings = GetConfigData(); var newTypeMapping = TypeMapping.Create <TFrom, TTo>(key, instantiationType); RemovePreviousMappingsForFromType(typeMappings, newTypeMapping); typeMappings.Add(newTypeMapping); SetTypeMappingsList(typeMappings); }
/// <summary> /// Bind an object to the object's type with specific initialization type and with supplied id as Key. This operation will ignore /// the [Singleton] or [Prototype] attributes that are declared in class attribute. /// </summary> /// <param name="type">Type of object to bind to.</param> /// <param name="obj">Target object.</param> /// <param name="instType">The initialization type.</param> /// <param name="id">Custom id of the object.</param> public void Bind <T>(T obj, InstantiationType instType, string id) { Type type = typeof(T); Dictionary <string, IoCObject> objectMap; if (!_objMap.TryGetValue(type, out objectMap)) { objectMap = new Dictionary <string, IoCObject>(); } objectMap[id] = new IoCObject(instType, obj); _objMap[type] = objectMap; }
public static Binding CreateForGeneric(IDIContext context, IList <Type> types, Type genericType, InstantiationType instantiationType, bool isDefault = true, string name = DEFAULT_BINDING) { var result = new Binding(); result.context = context; result.types = types; result.instance = genericType; result.instantiationType = InstantiationType.None; result.genericInstantiation = instantiationType; result.factory = null; result.instantiationFactory = null; result.name = name; result.makeDefault = isDefault; return(result); }
protected IBinding Bind(InstantiationType inst, IList <Type> types, Func <object> create, string name = null, bool makeDefault = false) { Func <object> factory = null; if (customFactoryWrapper != null) { factory = () => customFactoryWrapper(types, create); } else { factory = create; } IBinding binding = CreateBinding(inst, types, factory, name, makeDefault); this.context.Register(binding); return(binding); }
private static void InstantiatePersistent(InstantiationType type, EntityManager mgr, Entity prefabEntity, ref int existingAmount, int extraAmount) { switch (type) { case InstantiationType.Manager: if (extraAmount == 1) { mgr.InstantiatePersistent(prefabEntity, ref existingAmount); } else { mgr.InstantiatePersistent(prefabEntity, ref existingAmount, extraAmount); } break; case InstantiationType.Command: EntityCommandBuffer ecb = new EntityCommandBuffer(Allocator.Temp, PlaybackPolicy.SinglePlayback); ecb.InstantiatePersistent(prefabEntity, ref existingAmount, extraAmount); ecb.Playback(mgr); ecb.Dispose(); break; case InstantiationType.ParallelCommand: EntityCommandBuffer ecbParallel = new EntityCommandBuffer(Allocator.TempJob, PlaybackPolicy.SinglePlayback); var job = new ParallelInstantiateJob() { Ecb = ecbParallel.AsParallelWriter(), ExistingAmount = existingAmount, ExtraAmount = extraAmount, PrefabEntity = prefabEntity }; existingAmount += extraAmount; job.Schedule().Complete(); ecbParallel.Playback(mgr); ecbParallel.Dispose(); break; default: throw new ArgumentOutOfRangeException(nameof(type), type, null); } }
protected IBinding CreateBinding(InstantiationType inst, IList <Type> types, Func <object> create, string name, bool makeDefault) { if (string.IsNullOrEmpty(name)) { name = BindHelper.GetDefaultBindingName(context); } if (inst == InstantiationType.Abstract) { return(Binding.CreateForAbstract(this.context, types, create, makeDefault, name)); } else if (inst == InstantiationType.Concrete) { return(Binding.CreateForConcrete(this.context, types, create, makeDefault, name)); } else if (inst == InstantiationType.Instance) { return(Binding.CreateForInstance(this.context, types, create(), makeDefault, name)); } else { throw new MindiException("Unhandled instantiation type: " + inst); } }
public void TestDynamicPoolApplyAndPersist([Values(InstantiationType.Manager, InstantiationType.Command, InstantiationType.ParallelCommand)] InstantiationType instantiationType, [Values(1, 2, 3, 444, 5555)] int total, [Values(false, true)] bool groupedJobs) { // Prepare PersistencySettings settings = CreateTestSettings(); settings.ForceUseGroupedJobsInEditor = groupedJobs; settings.ForceUseNonGroupedJobsInBuild = !groupedJobs; Assert.True(groupedJobs == settings.UseGroupedJobs()); PersistentSceneSystem persistentSceneSystem = World.GetOrCreateSystem <PersistentSceneSystem>(); BeginFramePersistencySystem beginFramePersistencySystem = World.GetExistingSystem <BeginFramePersistencySystem>(); beginFramePersistencySystem.ReplaceSettings(settings); EndFramePersistencySystem endFramePersistencySystem = World.GetOrCreateSystem <EndFramePersistencySystem>(); endFramePersistencySystem.ReplaceSettings(settings); EndInitializationEntityCommandBufferSystem ecbSystem = World.GetOrCreateSystem <EndInitializationEntityCommandBufferSystem>(); PersistentDataStorage dataStorage = persistentSceneSystem.PersistentDataStorage; Hash128 identifier = Hash128.Compute("DynamicPoolTests"); NativeArray <PersistableTypeHandle> typeHandles = new NativeArray <PersistableTypeHandle>(Archetype.Length, Allocator.Persistent); for (int i = 0; i < typeHandles.Length; i++) { typeHandles[i] = settings.GetPersistableTypeHandleFromFullTypeName(Archetype[i].GetManagedType().FullName); // This is not advised in a game } // Action Entity prefabEntity = m_Manager.CreateEntity(Archetype); m_Manager.AddComponent <Prefab>(prefabEntity); persistentSceneSystem.InitializePool(prefabEntity, total, identifier, typeHandles); int amountSpawned = 0; InstantiatePersistent(instantiationType, m_Manager, prefabEntity, ref amountSpawned, total); persistentSceneSystem.InstantChangePoolCapacity(identifier, total * 2); // double amount InstantiatePersistent(instantiationType, m_Manager, prefabEntity, ref amountSpawned, total); m_Manager.RemoveComponent <EmptyEcsTestData>(m_Manager.CreateEntityQuery(typeof(PersistenceState))); Entities.ForEach((Entity e, ref EcsTestData testData, DynamicBuffer <DynamicBufferData1> buffer) => { testData.Value = 1; buffer.Add(new DynamicBufferData1() { Value = 1 }); }); dataStorage.ToIndex(0); endFramePersistencySystem.RequestPersist(dataStorage.GetWriteContainerForCurrentIndex(identifier)); endFramePersistencySystem.Update(); m_Manager.CompleteAllJobs(); beginFramePersistencySystem.RequestApply(dataStorage.GetInitialStateReadContainer(identifier)); beginFramePersistencySystem.Update(); ecbSystem.Update(); // Test int amountSurvivingEntities = m_Manager.CreateEntityQuery(typeof(EcsTestData)).CalculateEntityCount(); Assert.True(amountSurvivingEntities == total * 2, $"{instantiationType} didn't create the expected amount of entities({amountSurvivingEntities}vs{total*2})! (Or they were destroyed by Apply)"); Entities.ForEach((Entity e, ref EcsTestData testData, DynamicBuffer <DynamicBufferData1> buffer) => { Assert.True(testData.Value == 0, "The apply didn't restore the component value!"); Assert.True(buffer.IsEmpty, "The apply didn't restore the buffer!"); Assert.True(m_Manager.HasComponent <EmptyEcsTestData>(e), "The apply didn't restore the component!"); }); // Action dataStorage.ToIndex(0); beginFramePersistencySystem.RequestApply(dataStorage.GetWriteContainerForCurrentIndex(identifier)); beginFramePersistencySystem.Update(); ecbSystem.Update(); // Test amountSurvivingEntities = m_Manager.CreateEntityQuery(typeof(EcsTestData)).CalculateEntityCount(); Assert.True(amountSurvivingEntities == total * 2, $"Some entities were unexpectedly destroyed!"); Entities.ForEach((Entity e, ref EcsTestData testData, DynamicBuffer <DynamicBufferData1> buffer) => { Assert.True(testData.Value == 1, "The second apply didn't restore the component value!"); Assert.True(buffer[0].Value == 1, "The second apply didn't restore the buffer!"); Assert.False(m_Manager.HasComponent <EmptyEcsTestData>(e), "The second apply didn't restore the component!"); }); // Cleanup m_Manager.DestroyEntity(m_Manager.UniversalQuery); }
public void IncrementCtor(InstantiationType type) => _access.WriteUsing("ctor", type);
/// <summary> /// Bind an object to its type and the supplied id. /// Object must have the supplied type. /// This object will ingore the [Singleton] or [Prototype] attribute. /// </summary> /// <param name="obj">Target object.</param> /// <param name="instType">Singleton or Prototype.</param> /// <param name="id">Custom id of the object.</param> public void Bind <T>(T obj, InstantiationType instType, string id) { _container.Bind <T>(obj, instType, id); }
public static TypeMapping Create <TFrom, TTo>(InstantiationType instantiate) where TTo : TFrom { return(Create <TFrom, TTo>(null, instantiate)); }
/// <summary> /// Register a type mapping between fromType and toType with specified key. When <see cref="IServiceLocator.GetInstance(System.Type)"/> with /// parameter TFrom is called, an instance of type TTO is returned. /// </summary> /// <param name="fromType">The type to register type mappings for. </param> /// <param name="toType">The type to create if <see cref="IServiceLocator.GetInstance(System.Type)"/> is called with fromType. </param> /// <param name="key">The key that's used to store the type mapping.</param> /// <param name="instantiationType">Determines how the type should be created. </param> /// <returns>The service locator to make it easier to add multiple type mappings</returns> public ActivatingServiceLocator RegisterTypeMapping(Type fromType, Type toType, string key, InstantiationType instantiationType) { Validation.ArgumentNotNull(fromType, "fromType"); Validation.ArgumentNotNull(toType, "toType"); return(RegisterTypeMapping(new TypeMapping(fromType, toType, key) { InstantiationType = instantiationType })); }
public ActivatingServiceLocator RegisterTypeMapping <TFrom, TTo>(InstantiationType instantiationType) where TTo : TFrom, new() { return(RegisterTypeMapping(typeof(TFrom), typeof(TTo), null, instantiationType)); }
/// <summary> /// Bind an object to the object's type with supplied id as key. Object must have [Singleton] or [Prototype] declared as class attribute. /// </summary> /// <param name="type">Type of object to bind to.</param> /// <param name="obj">Target object.</param> /// <param name="id">Custom id of the object.</param> public void Bind <T>(T obj, string id) { InstantiationType instType = GetInstantiationType(obj.GetType()); Bind <T>(obj, instType, id); }
/// <summary> /// Register a type mapping between fromType and toType with specified key. When <see cref="IServiceLocator.GetInstance(System.Type)"/> with /// parameter TFrom is called, an instance of type TTO is returned. /// </summary> /// <param name="fromType">The type to register type mappings for. </param> /// <param name="toType">The type to create if <see cref="IServiceLocator.GetInstance(System.Type)"/> is called with fromType. </param> /// <param name="key">The key that's used to store the type mapping.</param> /// <param name="instantiationType">Determines how the type should be created. </param> /// <returns>The service locator to make it easier to add multiple type mappings</returns> public ActivatingServiceLocator RegisterTypeMapping(Type fromType, Type toType, string key, InstantiationType instantiationType) { return(RegisterTypeMapping(new TypeMapping(fromType, toType, key) { InstantiationType = instantiationType })); }
public IoCObject(InstantiationType instType, object obj) { this._instantiationType = instType; this._obj = obj; }
public ActivatingServiceLocator RegisterTypeMapping <TFrom, TTo>(string key, InstantiationType instantiationType) where TTo : TFrom, new() { return(this.RegisterTypeMapping(typeof(TFrom), typeof(TTo), key, instantiationType)); }
/// <summary> /// Bind an object to its type and the default id. /// Object must have the supplied type. /// This object will ingore the [Singleton] or [Prototype] attribute. /// </summary> /// <param name="instType">Singleton or Prototype.</param> /// <param name="obj">Target obj.</param> public static void Bind <T>(T obj, InstantiationType instType) { _injector.Bind <T>(obj, instType); }
/// <summary> /// Bind an object to its type and the supplied id. /// Object must have the supplied type. /// This object will ingore the [Singleton] or [Prototype] attribute. /// </summary> /// <param name="obj">Target object.</param> /// <param name="instType">Singleton or Prototype.</param> /// <param name="id">Custom id of the object.</param> public static void Bind <T>(T obj, InstantiationType instType, string id) { _injector.Bind <T>(obj, instType, id); }
/// <summary> /// Bind an object to its type and the default id. /// Object must have the supplied type. /// This object will ingore the [Singleton] or [Prototype] attribute. /// </summary> /// <param name="instType">Singleton or Prototype.</param> /// <param name="obj">Target obj.</param> public void Bind <T>(T obj, InstantiationType instType) { _container.Bind <T>(obj, instType, DEFAULT); }