/// <summary>
/// The view type has changed.
/// </summary>
/// <param name="activate">Should the current view type be activated?</param>
/// <param name="pitch">The pitch of the camera (in degrees).</param>
/// <param name="yaw">The yaw of the camera (in degrees).</param>
/// <param name="characterRotation">The rotation of the character.</param>
public override void ChangeViewType(bool activate, float pitch, float yaw, Quaternion characterRotation)
{
base.ChangeViewType(activate, pitch, yaw, characterRotation);
if (activate)
{
// Work with the handler to listen for any input events.
if (m_Handler != null)
{
m_StartFreeMovementInputEvent = GenericObjectPool.Get <ActiveInputEvent>();
m_StartFreeMovementInputEvent.Initialize(ActiveInputEvent.Type.ButtonDown, m_CameraFreeMovementInputName, "OnRPGViewTypeStartFreeMovement");
m_StopFreeMovementInputEvent = GenericObjectPool.Get <ActiveInputEvent>();
m_StopFreeMovementInputEvent.Initialize(ActiveInputEvent.Type.ButtonUp, m_CameraFreeMovementInputName, "OnRPGViewTypeStopFreeMovement");
m_Handler.RegisterInputEvent(m_StartFreeMovementInputEvent);
}
EventHandler.RegisterEvent(m_GameObject, "OnRPGViewTypeStartFreeMovement", OnStartFreeMovement);
EventHandler.RegisterEvent(m_GameObject, "OnRPGViewTypeStopFreeMovement", OnStopFreeMovement);
EventHandler.RegisterEvent(m_Character, "OnRPGMovementTypeStartRotate", OnStartCharacterRotate);
EventHandler.RegisterEvent(m_Character, "OnRPGMovementTypeStopRotate", OnStopCharacterRotate);
}
else
{
// The ViewType no longer needs to listen for input events when to ViewType is no longer active.
if (m_Handler != null)
{
if (m_FreeMovement)
{
m_Handler.UnregisterAbilityInputEvent(m_StopFreeMovementInputEvent);
}
else
{
m_Handler.UnregisterAbilityInputEvent(m_StartFreeMovementInputEvent);
}
GenericObjectPool.Return(m_StartFreeMovementInputEvent);
GenericObjectPool.Return(m_StopFreeMovementInputEvent);
}
EventHandler.UnregisterEvent(m_GameObject, "OnRPGViewTypeStartFreeMovement", OnStartFreeMovement);
EventHandler.UnregisterEvent(m_GameObject, "OnRPGViewTypeStopFreeMovement", OnStopFreeMovement);
EventHandler.UnregisterEvent(m_Character, "OnRPGMovementTypeStartRotate", OnStartCharacterRotate);
EventHandler.UnregisterEvent(m_Character, "OnRPGMovementTypeStopRotate", OnStopCharacterRotate);
}
}
/// <summary>
/// The ability has started.
/// </summary>
protected override void AbilityStarted()
{
m_ApplyHoldForce = true;
m_HoldForce = 0;
// If the jump has already been applied then it is a repeated jump.
if (m_JumpApplied)
{
OnAirborneJump();
}
else
{
if (!m_JumpEvent.WaitForAnimationEvent || m_ForceImmediateJump)
{
SchedulerBase.ScheduleFixed(m_ForceImmediateJump ? 0 : m_JumpEvent.Duration, ApplyJumpForce);
}
}
if (m_ForceHold > 0)
{
if (m_Handler != null && InputIndex != -1)
{
m_HoldInput = GenericObjectPool.Get <ActiveInputEvent>();
m_HoldInput.Initialize(ActiveInputEvent.Type.ButtonUp, InputNames[InputIndex], "OnJumpAbilityReleaseHold");
m_Handler.RegisterInputEvent(m_HoldInput);
}
EventHandler.RegisterEvent(m_GameObject, "OnJumpAbilityReleaseHold", OnReleaseHold);
}
// The character can do a repeated jump after the character is already in the air.
if (!m_AirborneJumpRegistered)
{
if (m_Handler != null && InputIndex != -1)
{
m_AirborneJumpInput = GenericObjectPool.Get <ActiveInputEvent>();
m_AirborneJumpInput.Initialize(ActiveInputEvent.Type.ButtonDown, InputNames[InputIndex], "OnJumpAbilityAirborneJump");
m_Handler.RegisterInputEvent(m_AirborneJumpInput);
}
EventHandler.RegisterEvent(m_GameObject, "OnJumpAbilityAirborneJump", OnPerformAirborneJump);
m_AirborneJumpRegistered = true;
}
m_ForceImmediateJump = false;
base.AbilityStarted();
}
public HierarchicalTimerWheel(TimerWheel[] wheels)
{
m_TaskPool = new GenericObjectPool <TimerTask>(() => new TimerTask(), null, (task) => task.Reset());
if (wheels != null && wheels.Length > 0)
{
m_Wheels = wheels;
for (int i = 0; i < wheels.Length; ++i)
{
TimerWheel wheel = wheels[i];
wheel.Level = i;
wheel.completeEvent = OnCompleted;
wheel.slotTriggerEvent = OnSoltTrigger;
}
m_LowLevelWheel = wheels[0];
}
}
public virtual void DoFixedUpdate()
{
//TODO moveStep skillStep etc...
unitFrameInfo = GenericObjectPool <UnitFrameInfo> .Get();
unitFrameInfo.frame = FrameManager.currentNetworkFrame;
unitFrameInfo.canMove = canMove;
unitFrameInfo.canRotate = canRotation;
if (canMove)
{
unitFrameInfo.position = position;
}
if (canRotation)
{
unitFrameInfo.rotation = rotation;
}
Debug.Log("DoFixedUpdate...");
}
/// <summary>
/// Stops managing the character.
/// </summary>
public void UnregisterCharacter()
{
if (m_CompleteInitEvent != null)
{
Scheduler.Cancel(m_CompleteInitEvent);
m_CompleteInitEvent = null;
}
if (m_SmoothedBones != null)
{
for (int i = 0; i < m_SmoothedBones.Length; ++i)
{
GenericObjectPool.Return(m_SmoothedBones[i]);
}
m_SmoothedBones = null;
}
EventHandler.UnregisterEvent <ILookSource>(m_CharacterLocomotion.gameObject, "OnCharacterAttachLookSource", OnAttachLookSource);
}
/// <summary>
/// Updates the shader to support a fade.
/// </summary>
/// <param name="material">The material to update.</param>
private void EnableFadeMaterial(Material material)
{
// If the character's materials change at runtime then the values need to be saved every time fading is enabled.
if (!m_CacheCharacterMaterials && !m_OriginalMaterialValuesMap.ContainsKey(material))
{
var originalMaterialValues = GenericObjectPool.Get <OriginalMaterialValue>();
originalMaterialValues.Initialize(material, m_ColorID, m_MaterialModeSet.Contains(material));
m_OriginalMaterialValuesMap.Add(material, originalMaterialValues);
}
if (m_MaterialModeSet.Contains(material))
{
material.SetFloat(OriginalMaterialValue.ModeID, 2);
material.SetInt(OriginalMaterialValue.SrcBlendID, (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
material.SetInt(OriginalMaterialValue.DstBlendID, (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
}
material.EnableKeyword(OriginalMaterialValue.AlphaBlendString);
material.renderQueue = 3000;
}
private static void TestGenericPool()
{
ConsoleWriter.Instance.WriteEmphasis("Generic Pool Test\n");
IGenericObjectPool <TestPoolItem> testPool = new GenericObjectPool <TestPoolItem>(10, BalancingMethods.RoundRobin);
List <TestPoolItem> items = new List <TestPoolItem>();
for (var i = 0; i < 5; i++)
{
items.Add(testPool.AcquireItem().Result);
}
ConsoleWriter.Instance.WriteInformation($"Count: {testPool.Count}\tSize: {testPool.Size}");
ConsoleWriter.Instance.WriteEmphasis("Press any key to acquire one more", true);
var itemAdded = testPool.AcquireItem().Result;
items.Add(itemAdded);
ConsoleWriter.Instance.WriteInformation($"Count: {testPool.Count}\tSize: {testPool.Size}");
ConsoleWriter.Instance.WriteEmphasis("Press any key to deactivate last added", true);
itemAdded.Deactivate();
ConsoleWriter.Instance.WriteInformation($"Count: {testPool.Count}\tSize: {testPool.Size}");
ConsoleWriter.Instance.WriteEmphasis("Press any key to release all", true);
for (var i = 0; i < items.Count; i++)
{
testPool.ReleaseItem(items[i]).Wait();
}
testPool.ContractItemPool();
Thread.Sleep(10);
ConsoleWriter.Instance.WriteInformation($"Count: {testPool.Count}\tSize: {testPool.Size}");
ConsoleWriter.Instance.WriteEmphasis("Press any key to quit", true);
testPool.Dispose();
ConsoleWriter.Instance.Dispose();
}
/// <summary>
/// The object has taken damage.
/// </summary>
/// <param name="amount">The amount of damage taken.</param>
/// <param name="position">The position of the damage.</param>
/// <param name="force">The amount of force applied to the object while taking the damage.</param>
/// <param name="attacker">The GameObject that did the damage.</param>
/// <param name="hitCollider">The Collider that was hit.</param>
private void OnDamage(float amount, Vector3 position, Vector3 force, GameObject attacker, Collider hitCollider)
{
// Don't show a hit indicator if the force is 0 or there is no attacker. This prevents damage such as fall damage from showing the damage indicator.
if ((!m_AlwaysShowIndicator && force.sqrMagnitude == 0) || attacker == null || m_ActiveDamageIndicatorCount == m_ActiveDamageIndicators.Length)
{
return;
}
var direction = Vector3.ProjectOnPlane(m_CharacterTransform.position - ((m_FollowAttacker && m_Character != attacker) ? attacker.transform.position : position),
m_CharacterLocomotion.Up);
// The hit indicator is shown on a 2D canvas so the y direction should be ignored.
direction.y = 0;
direction.Normalize();
// Determine the angle of the damage position to determine if a new damage indicator should be shown.
var angle = Vector3.Angle(direction, m_CameraTransform.forward) * Mathf.Sign(Vector3.Dot(direction, m_CameraTransform.right));
// Do not show a new damage indicator if the angle is less than a threshold compared to the already displayed indicators.
DamageIndicator damageIndicator;
for (int i = 0; i < m_ActiveDamageIndicatorCount; ++i)
{
damageIndicator = m_ActiveDamageIndicators[i];
if (Mathf.Abs(angle - damageIndicator.Angle) < m_IndicatorAngleThreshold)
{
damageIndicator.DisplayTime = Time.time;
m_ActiveDamageIndicators[i] = damageIndicator;
return;
}
}
// Add the indicator to the active hit indicators list and enable the component.
damageIndicator = GenericObjectPool.Get <DamageIndicator>();
damageIndicator.Initialize(attacker.transform, position, angle, m_StoredIndicators[m_DamageIndicatorIndex]);
m_ActiveDamageIndicators[m_ActiveDamageIndicatorCount] = damageIndicator;
m_ActiveDamageIndicatorCount++;
m_DamageIndicatorIndex = (m_DamageIndicatorIndex + 1) % m_StoredIndicators.Length;
// Allow the indicators to move/fade.
m_GameObject.SetActive(true);
}
static void Main(string[] args)
{
var connectionString = "Data Source=DESKTOP-QMR3K93;Initial Catalog=Testing;Integrated Security=True";
Loaders = new GenericObjectPool <DbLoader>(100, BalancingMethods.Random);
int rowCnt = 5000;
int loaderCnt = 0;
DateTime start = DateTime.Now;
for (var row = 0; row < rowCnt; row++)
{
List <string> columns = new List <string>();
for (var col = 0; col < 25; col++)
{
columns.Add($"somevalue{col}");
}
var loader = Loaders.AcquireItem(connectionString).Result;
if (string.IsNullOrEmpty(loader.Name))
{
loaderCnt++;
loader.Name = $"Loader {loaderCnt}";
}
loader.MaxCount = 500;
loader.Activate(connectionString);
loader.LoadIntoDatabase(columns);
}
var end = DateTime.Now;
Console.WriteLine($"{Loaders.Count} loaders started in {end - start}");
Console.WriteLine("\nPress any key to quit");
Console.ReadKey();
Loaders.Dispose();
}
//``````````````````````````````````````````````````````````````````````````````````````````````````````````````
//``````````````````````````````````````````````````````````````````````````````````````````````````````````````
private void Awake()
{
if (Instance != this)
{
Destroy(Instance);
}
Instance = this;
foreach (var item in PoolList)
{
for (int i = 0; i < item.size; i++)
{
GameObject obj = Instantiate(item.prefab);
obj.transform.SetParent(parentObject, true);
obj.SetActive(false);
gameObjectQueue.Enqueue(obj);
}
//poolDictionary.Add(item.name, gameObjectQueue);
}
}
/// <summary>
/// The ability has stopped running.
/// </summary>
/// <param name="force">Was the ability force stopped?</param>
protected override void AbilityStopped(bool force)
{
base.AbilityStopped(force);
// Update one last time with an axis value of 0 to return to the starting position.
m_AxisValue = 0;
UpdateLean(true);
// The collider is no longer needed.
if (m_ColliderGameObject != null)
{
m_ColliderGameObject.SetActive(false);
}
if (m_Handler != null)
{
m_Handler.UnregisterInputEvent(m_LeanInput);
GenericObjectPool.Return(m_LeanInput);
}
EventHandler.UnregisterEvent <float>(m_GameObject, "OnLeanInputUpdate", OnInputUpdate);
}
/// <summary>
/// The view type has changed.
/// </summary>
/// <param name="activate">Should the current view type be activated?</param>
/// <param name="pitch">The pitch of the camera (in degrees).</param>
/// <param name="yaw">The yaw of the camera (in degrees).</param>
/// <param name="characterRotation">The rotation of the character.</param>
public override void ChangeViewType(bool activate, float pitch, float yaw, Quaternion characterRotation)
{
if (activate)
{
m_Pitch = pitch;
m_Yaw = yaw;
m_CharacterRotation = characterRotation;
if (m_CharacterLocomotion.Platform != null)
{
UpdatePlatformRotationOffset(m_CharacterLocomotion.Platform);
}
if (m_Camera.fieldOfView != m_FieldOfView)
{
m_FieldOfViewChangeTime = Time.time + m_FieldOfViewDamping / m_CharacterLocomotion.TimeScale;
}
if (m_StepZoomSensitivity > 0)
{
if (m_Handler != null)
{
m_StepZoomInputEvent = GenericObjectPool.Get <ActiveInputEvent>();
m_StepZoomInputEvent.Initialize(ActiveInputEvent.Type.Axis, m_StepZoomInputName, "OnThirdPersonViewTypeStepZoom");
m_Handler.RegisterInputEvent(m_StepZoomInputEvent);
}
EventHandler.RegisterEvent <float>(m_GameObject, "OnThirdPersonViewTypeStepZoom", OnStepZoom);
}
}
else
{
if (m_StepZoomSensitivity > 0)
{
if (m_Handler != null)
{
m_StepZoomInputEvent = GenericObjectPool.Get <ActiveInputEvent>();
m_Handler.UnregisterAbilityInputEvent(m_StepZoomInputEvent);
GenericObjectPool.Return(m_StepZoomInputEvent);
}
EventHandler.UnregisterEvent <float>(m_GameObject, "OnThirdPersonViewTypeStepZoom", OnStepZoom);
}
}
}
public void ReturnObject(IDatabase db, IDbConnection conn)
{
GenericObjectPool <IDbConnection> pool = GetOrCreatePool(db);
pool.ReturnObject(conn);
if (db != null && db.Config.EnableLogConnectionPool == true)
{
db.LogHelper.Debug("-------------------ReturnObject IDbConnection:" + conn.GetHashCode() + "; status:" + conn.State);
db.LogHelper.Debug("CreatedCount:" + pool.CreatedCount + "; ActiveCount:" + pool.ActiveCount + "; BorrowedCount:" + pool.BorrowedCount
+ "; ReturnedCount:" + pool.ReturnedCount
+ "; MaxTotal:" + pool.MaxTotal
+ "; IdleCount:" + pool.IdleCount
+ "; NumIdle:" + pool.NumIdle
+ "; ActiveCount:" + pool.ActiveCount
+ "; NumActive:" + pool.NumActive
+ "; NumTests:" + pool.NumTests
+ "; DestroyedCount:" + pool.DestroyedCount
+ "; DestroyedByBorrowValidationCount:" + pool.DestroyedByBorrowValidationCount
);
}
}
/// <summary>
/// Perform the impact action.
/// </summary>
/// <param name="castID">The ID of the cast.</param>
/// <param name="source">The object that caused the cast.</param>
/// <param name="target">The object that was hit by the cast.</param>
/// <param name="hit">The raycast that caused the impact.</param>
protected override void ImpactInternal(uint castID, GameObject source, GameObject target, RaycastHit hit)
{
var damageTarget = DamageUtility.GetDamageTarget(target);
if (damageTarget == null || !damageTarget.IsAlive())
{
if (m_InterruptImpactOnNullHealth)
{
m_MagicItem.InterruptImpact();
}
return;
}
var pooledDamageData = GenericObjectPool.Get <DamageData>();
pooledDamageData.SetDamage(m_Amount, source.transform.position, (source.transform.position - target.transform.position), m_ForceMagnitude, m_ForceFrames, 0, source, this, null);
if (m_DamageProcessor == null)
{
m_DamageProcessor = DamageProcessor.Default;
}
m_DamageProcessor.Process(damageTarget, pooledDamageData);
GenericObjectPool.Return(pooledDamageData);
}
static QuadPool()
{
sm_ObjectListPool = new GenericObjectPool <List <IQuadObject> >(() =>
{
return(new List <IQuadObject>());
},
null,
(list) =>
{
list.Clear();
});
sm_NodeListPool = new GenericObjectPool <List <QuadNode> >(() =>
{
return(new List <QuadNode>());
},
null,
(list) =>
{
list.Clear();
});
}
/***** MONOBEHAVIOUR FUNCTIONS *****/
private void Awake()
{
Instance = this;
AddObject(initCount);
}
private void Awake()
{
Instance = this;
AddObjects(15);
}
private void Awake() => Instance = this;
void Awake()
{
Instance = this;
}
/***** MONOBEHAVIOUR FUNCTIONS *****/
protected override void Start()
{
base.Start();
virusPool = VirusPool.Instance;
}
public static T Pop <T>() where T : new()
{
return(GenericObjectPool <T> .Pop());
}
/// <summary>
/// Fade any objects that get in the way between the character and the camera.
/// </summary>
/// <param name="immediateFade">Should the fade material be changed immediately?</param>
private void FadeObstructingObjects(bool immediateFade)
{
if (!m_ObstructingObjectsFade)
{
return;
}
// Disable any obstructing colliders so the sphere cast can detect which objects are obstructing.
for (int i = 0; i < m_ObstructingCollidersCount; ++i)
{
m_ObstructingColliders[i].enabled = true;
}
m_ObstructingCollidersCount = 0;
var characterPosition = m_CharacterTransform.TransformPoint(m_TransformOffset);
var direction = (m_Transform.position - characterPosition);
var start = characterPosition - direction.normalized * m_CollisionRadius;
m_CharacterLocomotion.EnableColliderCollisionLayer(false);
// Fire a sphere to prevent the camera from colliding with other objects.
var hitCount = Physics.SphereCastNonAlloc(start, m_CollisionRadius, direction.normalized, m_RaycastsHit,
direction.magnitude, m_CharacterLayerManager.IgnoreInvisibleCharacterWaterLayers, QueryTriggerInteraction.Ignore);
m_CharacterLocomotion.EnableColliderCollisionLayer(true);
m_ObstructionHitSet.Clear();
if (hitCount > 0)
{
// Loop through all of the hit colliders. For any collider that has been hit get all of the renderers. The materials that are used on the
// renderers then need to be checked to determine if they can be faded. If the material can be faded place it in a set which will then
// be checked in the next block to determine if the material should be faded.
for (int i = 0; i < hitCount; ++i)
{
var renderers = m_RaycastsHit[i].transform.gameObject.GetCachedComponents <Renderer>();
var obstructing = false;
for (int j = 0; j < renderers.Length; ++j)
{
var materials = renderers[j].materials;
for (int k = 0; k < materials.Length; ++k)
{
if (!m_CanObstructionFade.TryGetValue(materials[k], out var canFade))
{
// Objects can fade if they have the color property and can be transparent.
canFade = materials[k].HasProperty(m_ColorID) && (m_AutoSetMode || materials[k].renderQueue >= (int)UnityEngine.Rendering.RenderQueue.Transparent);
m_CanObstructionFade.Add(materials[k], canFade);
}
if (canFade)
{
var material = materials[k];
// Any material contained within the hit set should be faded.
m_ObstructionHitSet.Add(material);
if (m_DisableCollider && !obstructing)
{
obstructing = CanMaterialFade(material);
}
// The same material may be applied to multiple renderers.
if (!m_OriginalMaterialValuesMap.ContainsKey(material))
{
// Don't set the mode automatically just because it has the property - not all objects in the environment should fade.
if (m_AutoSetMode && material.HasProperty(OriginalMaterialValue.ModeID))
{
m_MaterialModeSet.Add(material);
}
var originalMaterialValues = GenericObjectPool.Get <OriginalMaterialValue>();
originalMaterialValues.Initialize(material, m_ColorID, m_MaterialModeSet.Contains(material));
m_OriginalMaterialValuesMap.Add(material, originalMaterialValues);
m_ObstructingMaterials[m_ObstructingMaterialsCount] = material;
m_ObstructingMaterialsCount++;
EnableFadeMaterial(material);
}
}
}
}
// If the object is faded then the collider has the option of being disabled to prevent it from causing collisions.
if (m_DisableCollider && obstructing)
{
m_RaycastsHit[i].collider.enabled = false;
m_ObstructingColliders[m_ObstructingCollidersCount] = m_RaycastsHit[i].collider;
m_ObstructingCollidersCount++;
}
}
}
// Once the obstructing objects have been found they should be faded. Note that this can cause a lot of overdraw so the FadeObject method can be
// overridden to provide a custom effect such as the one described on https://madewith.unity.com/stories/dissolving-the-world-part-1.
for (int i = m_ObstructingMaterialsCount - 1; i >= 0; --i)
{
if (!FadeMaterial(m_ObstructingMaterials[i], m_ObstructionHitSet.Contains(m_ObstructingMaterials[i]), immediateFade))
{
RemoveObstructingMaterial(i);
}
}
}
/***** MONOBEHAVIOUR FUNCTIONS *****/
protected override void Start()
{
base.Start();
bacteriaCellPool = BacteriaCellPool.Instance;
}
private void Awake()
{
Instance = this;
}
public static GenericObjectPool <T> CreatePool(T prefab, int numPoolItems = 10)
{
GenericObjectPool <T> pool = new GenericObjectPool <T>(prefab, numPoolItems);
return(pool);
}
/// <summary>
/// Initializes the materials on the renderers for character fade.
/// </summary>
/// <param name="renderers">The renderers that should be initilaizes for character fade.</param>
private void InitializeCharacterFadeRenderers(Renderer[] renderers)
{
var count = 0;
for (int i = 0; i < renderers.Length; ++i)
{
// The renderer fade can be ignored.
if (renderers[i].gameObject.GetCachedComponent <IgnoreFadeIdentifier>() != null)
{
continue;
}
var materials = renderers[i].materials;
for (int j = 0; j < materials.Length; ++j)
{
if (!m_RegisteredMaterial.Contains(materials[j]) && materials[j].HasProperty(m_ColorID))
{
count++;
}
}
}
if (count > 0)
{
var totalCount = m_CharacterFadeMaterialsCount + count;
if (m_CharacterFadeMaterials == null)
{
m_CharacterFadeMaterials = new Material[totalCount];
}
else if (totalCount >= m_CharacterFadeMaterials.Length)
{
System.Array.Resize(ref m_CharacterFadeMaterials, totalCount);
}
// Cache a reference to all of the faded materials.
for (int i = 0; i < renderers.Length; ++i)
{
// The renderer fade can be ignored.
if (renderers[i].gameObject.GetCachedComponent <IgnoreFadeIdentifier>() != null)
{
continue;
}
var materials = renderers[i].materials;
for (int j = 0; j < materials.Length; ++j)
{
if (!m_RegisteredMaterial.Contains(materials[j]) && materials[j].HasProperty(m_ColorID))
{
if (materials[j].HasProperty(OriginalMaterialValue.ModeID))
{
m_MaterialModeSet.Add(materials[j]);
}
m_CharacterFadeMaterials[m_CharacterFadeMaterialsCount] = materials[j];
m_RegisteredMaterial.Add(materials[j]);
m_CharacterFadeMaterialsCount++;
if (m_CacheCharacterMaterials && !m_OriginalMaterialValuesMap.ContainsKey(materials[j]))
{
var originalMaterialValues = GenericObjectPool.Get <OriginalMaterialValue>();
originalMaterialValues.Initialize(materials[j], m_ColorID, m_MaterialModeSet.Contains(materials[j]));
m_OriginalMaterialValuesMap.Add(materials[j], originalMaterialValues);
}
}
}
}
}
}
public static void Push <T>(T obj) where T : new()
{
GenericObjectPool <T> .Push(obj);
}
/// <summary>
/// Attaches the component to the specified character.
/// </summary>
/// <param name="character">The handler to attach the camera to.</param>
protected virtual void OnAttachCharacter(GameObject character)
{
enabled = character != null && !m_CameraController.ActiveViewType.FirstPersonPerspective;
// Disable the fade on the previous active character.
if (m_CharacterFade)
{
if (m_Character != null && m_Character != character)
{
DisableFades();
// Clear the previous mappings.
if (m_CharacterFadeMaterials != null)
{
if (m_CacheCharacterMaterials)
{
for (int i = 0; i < m_CharacterFadeMaterials.Length; ++i)
{
if (!m_OriginalMaterialValuesMap.ContainsKey(m_CharacterFadeMaterials[i]))
{
continue;
}
GenericObjectPool.Return(m_OriginalMaterialValuesMap[m_CharacterFadeMaterials[i]]);
m_OriginalMaterialValuesMap.Remove(m_CharacterFadeMaterials[i]);
}
}
m_CharacterFadeMaterials = null;
}
m_OriginalMaterialValuesMap.Clear();
EventHandler.UnregisterEvent <bool>(m_Character, "OnCameraChangePerspectives", OnChangePerspectives);
EventHandler.UnregisterEvent <bool, bool>(m_Character, "OnCharacterIndependentFade", OnIndependentFade);
EventHandler.UnregisterEvent <Item>(m_Character, "OnInventoryAddItem", OnAddItem);
EventHandler.UnregisterEvent <GameObject, bool>(m_Character, "OnShootableWeaponShowProjectile", OnShowProjectile);
EventHandler.UnregisterEvent(m_Character, "OnRespawn", OnRespawn);
}
}
m_Character = character;
if (m_Character != null)
{
m_CharacterTransform = m_Character.transform;
m_CharacterLocomotion = m_Character.GetCachedComponent <UltimateCharacterLocomotion>();
m_CharacterLayerManager = m_Character.GetCachedComponent <CharacterLayerManager>();
if (m_CharacterFade)
{
// Determine the number of renderers that will be faded so their materials can be cached.
m_RegisteredMaterial.Clear();
var count = 0;
var renderers = m_Character.GetComponentsInChildren <Renderer>(true);
for (int i = 0; i < renderers.Length; ++i)
{
// The renderer fade can be ignored.
if (renderers[i].gameObject.GetCachedComponent <IgnoreFadeIdentifier>() != null)
{
continue;
}
var materials = renderers[i].materials;
for (int j = 0; j < materials.Length; ++j)
{
if (materials[j].HasProperty(m_ColorID))
{
count++;
}
}
}
if (count > 0)
{
if (m_CharacterFadeMaterials == null)
{
m_CharacterFadeMaterials = new Material[count];
}
else if (m_CharacterFadeMaterials.Length != count)
{
if (m_CacheCharacterMaterials)
{
// The mapping may exist from a previous character.
for (int i = 0; i < m_CharacterFadeMaterials.Length; ++i)
{
GenericObjectPool.Return(m_OriginalMaterialValuesMap[m_CharacterFadeMaterials[i]]);
m_OriginalMaterialValuesMap.Remove(m_CharacterFadeMaterials[i]);
}
}
System.Array.Resize(ref m_CharacterFadeMaterials, count);
}
// Cache a reference to all of the faded materials.
m_CharacterFadeMaterialsCount = 0;
for (int i = 0; i < renderers.Length; ++i)
{
// The renderer fade can be ignored.
if (renderers[i].gameObject.GetCachedComponent <IgnoreFadeIdentifier>() != null)
{
continue;
}
var materials = renderers[i].materials;
for (int j = 0; j < materials.Length; ++j)
{
if (m_RegisteredMaterial.Contains(materials[j]))
{
continue;
}
if (materials[j].HasProperty(m_ColorID))
{
if (materials[j].HasProperty(OriginalMaterialValue.ModeID))
{
m_MaterialModeSet.Add(materials[j]);
}
m_CharacterFadeMaterials[m_CharacterFadeMaterialsCount] = materials[j];
m_RegisteredMaterial.Add(materials[j]);
m_CharacterFadeMaterialsCount++;
if (m_CacheCharacterMaterials)
{
var originalMaterialValues = GenericObjectPool.Get <OriginalMaterialValue>();
originalMaterialValues.Initialize(materials[j], m_ColorID, m_MaterialModeSet.Contains(materials[j]));
m_OriginalMaterialValuesMap.Add(materials[j], originalMaterialValues);
}
}
}
}
}
EventHandler.RegisterEvent <bool>(m_Character, "OnCameraChangePerspectives", OnChangePerspectives);
EventHandler.RegisterEvent <Item>(m_Character, "OnInventoryAddItem", OnAddItem);
EventHandler.RegisterEvent <GameObject, bool>(m_Character, "OnShootableWeaponShowProjectile", OnShowProjectile);
EventHandler.RegisterEvent <bool, bool>(m_Character, "OnCharacterIndependentFade", OnIndependentFade);
EventHandler.RegisterEvent(m_Character, "OnRespawn", OnRespawn);
}
// Fade the obstructing objects immediately after the character has been assigned.
if (m_ObstructingObjectsFade)
{
FadeObstructingObjects(true);
}
}
}
/// <summary>
/// The object has collided with another object.
/// </summary>
/// <param name="hit">The RaycastHit of the object. Can be null.</param>
protected override void OnCollision(RaycastHit?hit)
{
base.OnCollision(hit);
var forceDestruct = false;
if (m_CollisionMode == CollisionMode.Collide)
{
// When there is a collision the object should move to the position that was hit so if it's not destroyed then it looks like it
// is penetrating the hit object.
if (hit != null && hit.HasValue && m_Collider != null)
{
var closestPoint = m_Collider.ClosestPoint(hit.Value.point);
m_Transform.position += (hit.Value.point - closestPoint);
// Only set the parent to the hit transform on uniform objects to prevent stretching.
if (MathUtility.IsUniform(hit.Value.transform.localScale))
{
// The parent layer must be within the sticky layer mask.
if (MathUtility.InLayerMask(hit.Value.transform.gameObject.layer, m_StickyLayers))
{
m_Transform.parent = hit.Value.transform;
// If the destructible sticks to a character then the object should be added as a sub collider so collisions will be ignored.
m_StickyCharacterLocomotion = hit.Value.transform.gameObject.GetCachedComponent <UltimateCharacterLocomotion>();
if (m_StickyCharacterLocomotion != null)
{
m_StickyCharacterLocomotion.AddIgnoredCollider(m_Collider);
}
}
else
{
forceDestruct = true;
}
}
}
if (m_TrailRenderer != null)
{
m_TrailRenderer.enabled = false;
}
}
var destructionDelay = m_DestructionDelay;
if (m_ParticleSystem != null && m_WaitForParticleStop)
{
destructionDelay = m_ParticleSystem.main.duration;
m_ParticleSystem.Stop(true, ParticleSystemStopBehavior.StopEmitting);
Stop();
}
// The object may not have been initialized before it collides.
if (m_GameObject == null)
{
InitializeComponentReferences();
}
if (hit != null && hit.HasValue)
{
var hitValue = hit.Value;
var hitGameObject = hitValue.collider.gameObject;
// The shield can absorb some (or none) of the damage from the destructible.
var damageAmount = m_DamageAmount;
#if ULTIMATE_CHARACTER_CONTROLLER_MELEE
ShieldCollider shieldCollider;
if ((shieldCollider = hitGameObject.GetCachedComponent <ShieldCollider>()) != null)
{
damageAmount = shieldCollider.Shield.Damage(this, damageAmount);
}
#endif
// Allow a custom event to be received.
EventHandler.ExecuteEvent <float, Vector3, Vector3, GameObject, object, Collider>(hitGameObject, "OnObjectImpact", damageAmount, hitValue.point, m_Velocity.normalized * m_ImpactForce, m_Originator, this, hitValue.collider);
if (m_OnImpactEvent != null)
{
m_OnImpactEvent.Invoke(damageAmount, hitValue.point, m_Velocity.normalized * m_ImpactForce, m_Originator);
}
// If the shield didn't absorb all of the damage then it should be applied to the character.
if (damageAmount > 0)
{
var damageTarget = DamageUtility.GetDamageTarget(hitGameObject);
if (damageTarget != null)
{
var pooledDamageData = GenericObjectPool.Get <DamageData>();
pooledDamageData.SetDamage(this, damageAmount, hitValue.point, -hitValue.normal, m_ImpactForce, m_ImpactForceFrames, 0, hitValue.collider);
var damageProcessorModule = hitGameObject.GetCachedComponent <DamageProcessorModule>();
if (damageProcessorModule != null)
{
damageProcessorModule.ProcessDamage(m_DamageProcessor, damageTarget, pooledDamageData);
}
else
{
if (m_DamageProcessor == null)
{
m_DamageProcessor = DamageProcessor.Default;
}
m_DamageProcessor.Process(damageTarget, pooledDamageData);
}
GenericObjectPool.Return(pooledDamageData);
}
else if (m_ImpactForce > 0)
{
// If the damage target exists it will apply a force to the rigidbody in addition to procesing the damage. Otherwise just apply the force to the rigidbody.
var collisionRigidbody = hitGameObject.GetCachedParentComponent <Rigidbody>();
if (collisionRigidbody != null && !collisionRigidbody.isKinematic)
{
collisionRigidbody.AddForceAtPosition(m_ImpactForce * MathUtility.RigidbodyForceMultiplier * -hitValue.normal, hitValue.point);
}
else
{
var forceObject = hitGameObject.GetCachedParentComponent <IForceObject>();
if (forceObject != null)
{
forceObject.AddForce(m_Transform.forward * m_ImpactForce);
}
}
}
}
// An optional state can be activated on the hit object.
if (!string.IsNullOrEmpty(m_ImpactStateName))
{
StateManager.SetState(hitGameObject, m_ImpactStateName, true);
// If the timer isn't -1 then the state should be disabled after a specified amount of time. If it is -1 then the state
// will have to be disabled manually.
if (m_ImpactStateDisableTimer != -1)
{
StateManager.DeactivateStateTimer(hitGameObject, m_ImpactStateName, m_ImpactStateDisableTimer);
}
}
}
// The object can destroy itself after a small delay.
if (m_DestroyEvent == null && (m_DestroyOnCollision || forceDestruct || destructionDelay > 0))
{
m_DestroyEvent = SchedulerBase.ScheduleFixed(destructionDelay, Destruct, hit);
}
}
/**
* Create a new GenericObjectPoolFactory.
*
* @param factory the PoolableObjectFactory used by created pools.
* @param config a non-<code>null</code> GenericObjectPool<T>.Config describing the configuration.
* @throws NullPointerException when config is <code>null</code>.
* @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, GenericObjectPool<T>.Config)
*/
public GenericObjectPoolFactory(PoolableObjectFactory <T> factory, GenericObjectPool <T> .Config config) :// throws NullPointerException {
this(factory, config.maxActive, config.whenExhaustedAction, config.maxWait, config.maxIdle, config.minIdle, config.testOnBorrow, config.testOnReturn, config.timeBetweenEvictionRunsMillis, config.numTestsPerEvictionRun, config.minEvictableIdleTimeMillis, config.testWhileIdle, config.softMinEvictableIdleTimeMillis, config.lifo)
{
}
