protected ImpactTagMask?getOtherObjectTagMask(IImpactObject impactObject, Vector3 point, int otherPhysicsMaterialID, bool hasOtherObject)
{
if (hasOtherObject)
{
IImpactMaterial m = impactObject.GetPrimaryMaterial(point);
if (m != null)
{
return(m.MaterialTagsMask);
}
else if (ImpactManagerInstance.UseMaterialMapping && ImpactManagerInstance.TryGetImpactMaterialFromMapping(otherPhysicsMaterialID, out m))
{
return(m.MaterialTagsMask);
}
}
else
{
IImpactMaterial m;
if (ImpactManagerInstance.UseMaterialMapping && ImpactManagerInstance.TryGetImpactMaterialFromMapping(otherPhysicsMaterialID, out m))
{
return(m.MaterialTagsMask);
}
}
return(null);
}
private static void triggerOnHitObject <T>(T interactionData, IImpactObject otherObject, int physicsMaterialId, bool useMaterialComposition) where T : IInteractionData
{
if (otherObject != null)
{
if (useMaterialComposition)
{
int count = otherObject.GetMaterialCompositionNonAlloc(interactionData.Point, ImpactManagerInstance.MaterialCompositionBuffer);
for (int i = 0; i < count; i++)
{
ImpactMaterialComposition comp = ImpactManagerInstance.MaterialCompositionBuffer[i];
if (comp.CompositionValue > 0)
{
IInteractionData newInteractionData = interactionData.Clone();
newInteractionData.CompositionValue = comp.CompositionValue;
ImpactManagerInstance.ProcessInteraction(newInteractionData, comp.Material, otherObject);
}
}
}
else
{
ImpactManagerInstance.ProcessInteraction(interactionData, otherObject);
}
}
else if (ImpactManagerInstance.UseMaterialMapping)
{
IImpactMaterial m;
if (ImpactManagerInstance.TryGetImpactMaterialFromMapping(physicsMaterialId, out m))
{
ImpactManagerInstance.ProcessInteraction(interactionData, m, null);
}
}
}
public void Dispose()
{
parent = null;
DecalTemplate = null;
MakeAvailable();
}
/// <summary>
/// Process interaction data using the given Impact Object. The primary material at the interaction point will be used.
/// </summary>
/// <param name="interactionData">The interaction data to process.</param>
/// <param name="impactObject">The Impact Object that the primary Impact Material will be retrieved from.</param>
public static void ProcessInteraction <T>(T interactionData, IImpactObject impactObject) where T : IInteractionData
{
if (impactObject == null)
{
return;
}
ProcessInteraction(interactionData, impactObject.GetPrimaryMaterial(interactionData.Point), impactObject);
}
/// <summary>
/// Trigger an interaction from a 2D raycast. Impact Material data will be retrieved from the object that was hit by the raycast. The interaction will be processed using the given IImpactObject.
/// </summary>
/// <param name="hit">Raycast 2D hit data. The contact point, normal, and the object that was hit will be retrived from this.</param>
/// <param name="impactObject">The Impact Object the resulting interaction will be processed on.</param>
/// <param name="velocity">The velocity of the interaction.</param>
/// <param name="interactionType">The type of interaction.</param>
/// <param name="useMaterialComposition">Should this trigger use the material composition of the object it hit by the raycast?</param>
public static void Trigger2D(IImpactObject impactObject, RaycastHit2D hit, Vector3 velocity, int interactionType, bool useMaterialComposition)
{
InteractionData interactionData = new InteractionData();
interactionData.InteractionType = interactionType;
interactionData.Velocity = velocity;
interactionData.ThisObject = impactObject.GameObject;
Trigger2D(interactionData, hit, impactObject, useMaterialComposition);
}
/// <summary>
/// Gets the priority, either from the Interaction Data Priority Override or from the Impact Object.
/// </summary>
/// <param name="collisionResult">The collision result to get the priority for.</param>
/// <param name="obj">The impact object to get the priority from.</param>
/// <returns>The priority, either from the Interaction Data Priority Override or from the Impact Object.</returns>
public static int GetPriority(int?priorityOverride, IImpactObject obj)
{
if (priorityOverride.HasValue)
{
return(priorityOverride.Value);
}
else if (obj != null)
{
return(obj.Priority);
}
return(0);
}
/// <summary>
/// Adds or updates the given continuous interaction result to the active continuous interaction results, if able.
/// </summary>
/// <param name="impactObject">The impact object the result is being sent from.</param>
/// <param name="result">The new continuous interaction result.</param>
public void AddOrUpdateContinuousInteractionResult(IImpactObject impactObject, IContinuousInteractionResult result)
{
IContinuousInteractionResult existing = findContinuousInteractionResult(result.Key);
if (existing != null)
{
existing.KeepAlive(result);
result.Dispose();
}
else
{
addContinuousInteractionResult(impactObject, result);
}
}
/// <summary>
/// Play audio using our data.
/// </summary>
/// <param name="parent">The Impact Object that created this result.</param>
public void Process(IImpactObject parent)
{
this.parent = parent;
audioSource = ImpactAudioPool.PlayAudio(this, OriginalData.Point, InteractionResultExtensions.GetPriority(OriginalData.PriorityOverride, parent));
targetVolume = currentVolume = Volume;
targetPitch = currentPitch = Pitch;
//Dispose immediately for Collision interaction types
if (OriginalData.InteractionType == InteractionData.InteractionTypeCollision)
{
Dispose();
}
}
protected override void buildInteractionData(IImpactObject target, TCollision collision, TContact contactPoint,
VelocityData myVelocityData, VelocityData otherVelocityData, ImpactTagMask?tagMask, float compositionValue)
{
Vector3 relativeContactPointVelocity = myVelocityData.TotalPointVelocity - otherVelocityData.TotalPointVelocity;
if (SlideMode != SlideMode.None)
{
InteractionData slideParameters = new InteractionData()
{
TagMask = tagMask,
Point = contactPoint.Point,
Normal = contactPoint.Normal,
Velocity = relativeContactPointVelocity,
InteractionType = InteractionData.InteractionTypeSlide,
ThisObject = contactPoint.ThisObject,
OtherObject = contactPoint.OtherObject,
CompositionValue = compositionValue
};
invokeTriggeredEvent(slideParameters, target);
ImpactManagerInstance.ProcessContinuousInteraction(slideParameters, target);
}
if (RollMode != RollMode.None)
{
float roll = 1 - Mathf.Clamp01(relativeContactPointVelocity.magnitude * 0.1f);
if (roll > 0)
{
Vector3 rollVelocity = myVelocityData.TangentialVelocity * roll;
InteractionData rollParameters = new InteractionData()
{
TagMask = tagMask,
Point = contactPoint.Point,
Normal = contactPoint.Normal,
Velocity = rollVelocity,
InteractionType = InteractionData.InteractionTypeRoll,
ThisObject = contactPoint.ThisObject,
OtherObject = contactPoint.OtherObject,
CompositionValue = compositionValue
};
invokeTriggeredEvent(rollParameters, target);
ImpactManagerInstance.ProcessContinuousInteraction(rollParameters, target);
}
}
}
/// <summary>
/// Process a collision contact to get all material and velocity data.
/// The material and velocity data will be sent to buildInteractionData, which you can override.
/// </summary>
/// <param name="collision">The original collision data.</param>
/// <param name="contactPoint">The contact point of the collision to use in calculations.</param>
protected void processCollisionContact(TCollision collision, TContact contactPoint)
{
IImpactObject myObject = getImpactObject(contactPoint.ThisObject);
if (myObject != null)
{
IImpactObject otherObject = contactPoint.OtherObject.GetComponentInParent <IImpactObject>();
bool hasOtherObject = otherObject != null;
//Material composition is enabled
if (UseMaterialComposition && hasOtherObject)
{
//Get material composition
int count = otherObject.GetMaterialCompositionNonAlloc(contactPoint.Point, ImpactManagerInstance.MaterialCompositionBuffer);
//Get velocity data
VelocityData myVelocityData = myObject.GetVelocityDataAtPoint(contactPoint.Point);
VelocityData otherVelocityData = otherObject.GetVelocityDataAtPoint(contactPoint.Point);
//Create interaction for each material
for (int i = 0; i < count; i++)
{
ImpactMaterialComposition comp = ImpactManagerInstance.MaterialCompositionBuffer[i];
if (comp.CompositionValue > 0)
{
buildInteractionData(myObject, collision, contactPoint, myVelocityData, otherVelocityData, comp.Material.MaterialTagsMask, comp.CompositionValue);
}
}
}
//Material composition is not enabled
else
{
//Get velocity data
VelocityData otherVelocityData = hasOtherObject ? otherObject.GetVelocityDataAtPoint(contactPoint.Point) : new VelocityData();
VelocityData myVelocityData = myObject.GetVelocityDataAtPoint(contactPoint.Point);
//Get tag mask
ImpactTagMask?tagMask = getOtherObjectTagMask(otherObject, contactPoint.Point, contactPoint.OtherPhysicsMaterialID, hasOtherObject);
//Create interaction
buildInteractionData(myObject, collision, contactPoint, myVelocityData, otherVelocityData, tagMask, 1);
}
}
else
{
//Impact object could not be found. MainTarget is not assigned and no Impact Object could be determined from the contact point.
Debug.LogError("Unable to find Impact Object on GameObject " + gameObject.name);
}
}
/// <summary>
/// Stops the audio source associated with this result so it becomes available in the audio source object pool.
/// </summary>
public void Dispose()
{
if (OriginalData.InteractionType != InteractionData.InteractionTypeCollision && audioSource != null)
{
audioSource.StopAudio();
}
AudioSourceTemplate = null;
audioSource = null;
AudioClip = null;
Interaction = null;
parent = null;
MakeAvailable();
}
/// <summary>
/// Emit particles using our data.
/// </summary>
/// <param name="parent">The Impact Object that created this result.</param>
public void Process(IImpactObject parent)
{
this.parent = parent;
particlesInstance = ImpactParticlePool.EmitParticles(this, OriginalData.Point, OriginalData.Normal, InteractionResultExtensions.GetPriority(OriginalData.PriorityOverride, parent));
IsAlive = true;
currentEmissionIntervalTarget = EmissionInterval.RandomInRange();
//Dispose immediately for Collision interaction types
if (OriginalData.InteractionType == InteractionData.InteractionTypeCollision)
{
Dispose();
}
}
private void addContinuousInteractionResult(IImpactObject impactObject, IContinuousInteractionResult continuousInteractionResult)
{
for (int i = 0; i < activeContinuousInteractionResults.Length; i++)
{
if (activeContinuousInteractionResults[i] == null)
{
activeContinuousInteractionResults[i] = continuousInteractionResult;
currentActiveContinuousInteractionCount++;
activeContinuousInteractionKeys.Add(continuousInteractionResult.Key);
continuousInteractionResult.Process(impactObject);
return;
}
}
continuousInteractionResult.Dispose();
}
/// <summary>
/// Place decals using our data.
/// </summary>
/// <param name="parent">The Impact Object that created this result.</param>
public void Process(IImpactObject parent)
{
this.parent = parent;
ImpactDecalPool.CreateDecal(this, OriginalData.Point, OriginalData.Normal);
IsAlive = true;
currentCreationIntervalTarget = CreationInterval.RandomInRange();
previousCreationPosition = OriginalData.Point;
//Dispose immediately for Collision interaction types
if (OriginalData.InteractionType == InteractionData.InteractionTypeCollision)
{
Dispose();
}
}
/// <summary>
/// Trigger an interaction from a 2D raycast. The interaction will be processed on the object that was hit by the raycast.
/// </summary>
/// <param name="hit">Raycast 2D hit data. The contact point, normal, and the object that was hit will be retrived from this.</param>
/// <param name="interactionData">The original interaction data. Velocity, TagMask, ThisObject, and InteractionType should already be set.</param>
/// <param name="useMaterialComposition">Should this trigger use the material composition of the object it hit by the raycast?</param>
public static void Trigger2D <T>(T interactionData, RaycastHit2D hit, bool useMaterialComposition) where T : IInteractionData
{
interactionData.OtherObject = hit.collider.gameObject;
interactionData.Point = hit.point;
interactionData.Normal = hit.normal;
interactionData.CompositionValue = 1;
IImpactObject otherObject = hit.collider.GetComponentInParent <IImpactObject>();
int physicsMaterialId = 0;
if (ImpactManagerInstance.UseMaterialMapping && hit.collider.sharedMaterial != null)
{
physicsMaterialId = hit.collider.sharedMaterial.GetInstanceID();
}
triggerOnHitObject(interactionData, otherObject, physicsMaterialId, useMaterialComposition);
}
protected void processSpeculativeCollision(TCollision collision)
{
int collisions = 0;
//Loop over all contacts of the collision
for (int i = 0; i < collision.ContactCount; i++)
{
TContact contactPoint = collision.GetContact(i);
IImpactObject thisObject = getImpactObject(contactPoint.ThisObject);
if (thisObject != null)
{
SpeculativeCollisionContact c = new SpeculativeCollisionContact()
{
RelativeContactPoint = thisObject.GetContactPointRelativePosition(contactPoint.Point),
Lifetime = _contactPointLifetime
};
//The relative position of the contact point serves as a unique identifier
//So we can keep track of contact points between frames
//If there is no existing point with the same relative position (within a threshold), then it is a "new" contact point.
//We then process the point, basically mimicking an OnCollisionEnter message.
int existingIndex = continousCollisionContacts.FindIndex(e => (e.RelativeContactPoint - c.RelativeContactPoint).sqrMagnitude < _contactPointComparisonThreshold);
if (existingIndex == -1)
{
continousCollisionContacts.Add(c);
if (collisions < MaxCollisionsPerFrame)
{
processCollisionContact(collision, contactPoint);
collisions++;
}
}
else
{
SpeculativeCollisionContact existingContact = continousCollisionContacts[existingIndex];
existingContact.Lifetime = _contactPointLifetime;
continousCollisionContacts[existingIndex] = existingContact;
}
}
}
}
private static void triggerOnRaycastingObject <T>(T interactionData, IImpactObject impactObject, IImpactObject otherObject, int physicsMaterialId, bool useMaterialComposition) where T : IInteractionData
{
if (otherObject != null)
{
if (useMaterialComposition)
{
int count = otherObject.GetMaterialCompositionNonAlloc(interactionData.Point, ImpactManagerInstance.MaterialCompositionBuffer);
for (int i = 0; i < count; i++)
{
ImpactMaterialComposition comp = ImpactManagerInstance.MaterialCompositionBuffer[i];
if (comp.CompositionValue > 0)
{
IInteractionData newInteractionData = interactionData.Clone();
newInteractionData.CompositionValue = comp.CompositionValue;
newInteractionData.TagMask = comp.Material.MaterialTagsMask;
ImpactManagerInstance.ProcessInteraction(newInteractionData, impactObject);
}
}
}
else
{
IImpactMaterial material = otherObject.GetPrimaryMaterial(interactionData.Point);
if (material != null || (ImpactManagerInstance.UseMaterialMapping && ImpactManagerInstance.TryGetImpactMaterialFromMapping(physicsMaterialId, out material)))
{
interactionData.TagMask = material.MaterialTagsMask;
}
ImpactManagerInstance.ProcessInteraction(interactionData, impactObject);
}
}
else if (ImpactManagerInstance.UseMaterialMapping)
{
IImpactMaterial material;
if (ImpactManagerInstance.TryGetImpactMaterialFromMapping(physicsMaterialId, out material))
{
interactionData.TagMask = material.MaterialTagsMask;
}
ImpactManagerInstance.ProcessInteraction(interactionData, impactObject);
}
}
protected override void buildInteractionData(IImpactObject target, TCollision collision, TContact contactPoint,
VelocityData myVelocityData, VelocityData otherVelocityData, ImpactTagMask?tagMask, float CompositionValue)
{
Vector3 relativeContactPointVelocity = myVelocityData.TotalPointVelocity - otherVelocityData.TotalPointVelocity;
InteractionData interactionData = new InteractionData()
{
TagMask = tagMask,
Point = contactPoint.Point,
Normal = contactPoint.Normal,
Velocity = relativeContactPointVelocity,
InteractionType = InteractionData.InteractionTypeCollision,
ThisObject = contactPoint.ThisObject,
OtherObject = contactPoint.OtherObject,
CompositionValue = CompositionValue
};
invokeTriggeredEvent(interactionData, target);
ImpactManagerInstance.ProcessInteraction(interactionData, target);
}
protected override void buildInteractionData(IImpactObject target, ImpactCollisionWrapper collision, ImpactContactPoint contactPoint,
VelocityData myVelocityData, VelocityData otherVelocityData, ImpactTagMask?tagMask, float CompositionValue)
{
VelocityData currentVelocityData = rigidbodyWrapper.GetCurrentVelocityData(contactPoint.Point);
Vector3 velocityChange = myVelocityData.TotalPointVelocity - currentVelocityData.TotalPointVelocity;
Vector3 relativeContactPointVelocity = myVelocityData.TotalPointVelocity - otherVelocityData.TotalPointVelocity;
InteractionData interactionData = new InteractionData()
{
TagMask = tagMask,
Point = contactPoint.Point,
Normal = contactPoint.Normal,
Velocity = Vector3.Lerp(relativeContactPointVelocity, velocityChange, _velocityChangeInfluence),
InteractionType = InteractionData.InteractionTypeCollision,
ThisObject = contactPoint.ThisObject,
OtherObject = contactPoint.OtherObject,
CompositionValue = CompositionValue
};
invokeTriggeredEvent(interactionData, target);
ImpactManagerInstance.ProcessInteraction(interactionData, target);
}
/// <summary>
/// Process a continuous interaction using the interaction data and the given Impact Object. The primary material at the interaction point will be used.
/// </summary>
/// <param name="interactionData">The interaction data to process.</param>
/// <param name="impactObject">The Impact Object that an Impact Material will be retrieved from.</param>
public static void ProcessContinuousInteraction <T>(T interactionData, IImpactObject impactObject) where T : IInteractionData
{
ImpactManager instance = GetInstance();
instance.ProcessContinuousInteraction(interactionData, impactObject.GetPrimaryMaterial(interactionData.Point), impactObject);
}
/// <summary>
/// Process a continuous interaction using the interaction data, an Impact Material, and an optional Impact Object that the interaction originated from.
/// </summary>
/// <param name="interactionData">The interaction data to process.</param>
/// <param name="impactMaterial">The Impact Material to get interaction results from.</param>
/// <param name="impactObject">An optional Impact Object that the interaction originated from.</param>
public static void ProcessContinuousInteraction <T>(T interactionData, IImpactMaterial material, IImpactObject impactObject) where T : IInteractionData
{
ImpactManager instance = GetInstance();
instance.ProcessContinuousInteraction(interactionData, material, impactObject);
}
/// <summary>
/// Adds or updates the given continuous interaction result to the active continuous interaction results, if able.
/// </summary>
/// <param name="impactObject">The impact object the result is being sent from.</param>
/// <param name="result">The new continuous interaction result.</param>
public static void AddOrUpdateContinuousInteractionResult(IImpactObject impactObject, IContinuousInteractionResult result)
{
ImpactManager instance = GetInstance();
instance.AddOrUpdateContinuousInteractionResult(impactObject, result);
}
protected void invokeTriggeredEvent(InteractionData interactionData, IImpactObject impactObject)
{
OnTriggered?.Invoke(interactionData, impactObject);
}
/// <summary>
/// Called by the process methods to build IInteractionData.
/// Override this if your custom triggers are using any of the process methods.
/// </summary>
/// <param name="target">The target IImpactObject to send data to. You do not necessarily have to send data to this object.</param>
/// <param name="collision">The collision being processed.</param>
/// <param name="contactPoint">The collision contact point.</param>
/// <param name="myVelocityData">The velocity data of this object.</param>
/// <param name="otherVelocityData">The velocity data of the object being collided with.</param>
/// <param name="tagMask">The tag mask obtained from the other object. Can be null.</param>
/// <param name="compositionValue">The material composition value.</param>
protected virtual void buildInteractionData(IImpactObject target, TCollision collision, TContact contactPoint, VelocityData myVelocityData, VelocityData otherVelocityData, ImpactTagMask?tagMask, float compositionValue)
{
}
private void processParticleCollision(ParticleCollisionEvent particleCollisionEvent, GameObject onParticleCollisionObject, bool isParticleSystem)
{
IImpactObject myObject;
//Particle system always uses the main target
if (isParticleSystem)
{
myObject = MainTarget;
}
//Non-particle system gets the object from the particle collision event's collider
else
{
myObject = getImpactObject(particleCollisionEvent.colliderComponent.gameObject);
}
if (myObject != null)
{
IImpactObject otherObject = null;
//Get other object based on whether or not this object is a particle system
if (isParticleSystem)
{
otherObject = particleCollisionEvent.colliderComponent.GetComponentInParent <IImpactObject>();
}
else
{
otherObject = onParticleCollisionObject.GetComponentInParent <IImpactObject>();
}
bool hasOtherObject = otherObject != null;
if (UseMaterialComposition && hasOtherObject)
{
int count = otherObject.GetMaterialCompositionNonAlloc(particleCollisionEvent.intersection, ImpactManagerInstance.MaterialCompositionBuffer);
//Velocity data is dependent on if this is a particle system or a not
VelocityData myVelocityData;
VelocityData otherVelocityData;
if (isParticleSystem)
{
myVelocityData = new VelocityData(particleCollisionEvent.velocity, Vector3.zero);
otherVelocityData = otherObject.GetVelocityDataAtPoint(particleCollisionEvent.intersection);
}
else
{
myVelocityData = myObject.GetVelocityDataAtPoint(particleCollisionEvent.intersection);
otherVelocityData = new VelocityData(particleCollisionEvent.velocity, Vector3.zero);
}
Vector3 relativeContactPointVelocity = myVelocityData.TotalPointVelocity - otherVelocityData.TotalPointVelocity;
for (int i = 0; i < count; i++)
{
ImpactMaterialComposition comp = ImpactManagerInstance.MaterialCompositionBuffer[i];
if (comp.CompositionValue > 0)
{
InteractionData interactionData = new InteractionData()
{
TagMask = comp.Material.MaterialTagsMask,
Point = particleCollisionEvent.intersection,
Normal = particleCollisionEvent.normal,
Velocity = relativeContactPointVelocity,
InteractionType = InteractionData.InteractionTypeCollision,
ThisObject = this.gameObject,
OtherObject = otherObject.GameObject,
CompositionValue = 1f
};
invokeTriggeredEvent(interactionData, myObject);
ImpactManagerInstance.ProcessInteraction(interactionData, myObject);
}
}
}
else
{
//Velocity data is dependent on if this is a particle system or a not
VelocityData myVelocityData;
VelocityData otherVelocityData;
if (isParticleSystem)
{
myVelocityData = new VelocityData(particleCollisionEvent.velocity, Vector3.zero);
otherVelocityData = hasOtherObject ? otherObject.GetVelocityDataAtPoint(particleCollisionEvent.intersection) : new VelocityData();
}
else
{
myVelocityData = myObject.GetVelocityDataAtPoint(particleCollisionEvent.intersection);
otherVelocityData = new VelocityData(particleCollisionEvent.velocity, Vector3.zero);
}
Vector3 relativeContactPointVelocity = myVelocityData.TotalPointVelocity - otherVelocityData.TotalPointVelocity;
//Get physics material ID for material mapping, but only if this object is a particle system.
//Particles don't have a collider so no need to try and get the physics material if this is not a particle system
int otherPhysicsMaterialID = isParticleSystem ? getPhysicsMaterialID(particleCollisionEvent.colliderComponent) : 0;
ImpactTagMask?tagMask = getOtherObjectTagMask(otherObject, particleCollisionEvent.intersection, otherPhysicsMaterialID, hasOtherObject);
InteractionData interactionData = new InteractionData()
{
TagMask = tagMask,
Point = particleCollisionEvent.intersection,
Normal = particleCollisionEvent.normal,
Velocity = relativeContactPointVelocity,
InteractionType = InteractionData.InteractionTypeCollision,
ThisObject = this.gameObject,
OtherObject = particleCollisionEvent.colliderComponent.gameObject,
CompositionValue = 1f
};
invokeTriggeredEvent(interactionData, myObject);
ImpactManagerInstance.ProcessInteraction(interactionData, myObject);
}
}
else
{
Debug.LogError("Unable to find Impact Object on GameObject " + gameObject.name);
}
}
/// <summary>
/// Process interaction data using the Impact Material and an optional Impact Object that the interaction originated from.
/// </summary>
/// <param name="interactionData">The interaction data to process.</param>
/// <param name="impactMaterial">The Impact Material to get interaction results from.</param>
/// <param name="impactObject">An optional Impact Object that the interaction originated from.</param>
public void ProcessInteraction <T>(T interactionData, IImpactMaterial impactMaterial, IImpactObject impactObject) where T : IInteractionData
{
int count = impactMaterial.GetInteractionResultsNonAlloc(interactionData, InteractionResultBuffer);
for (int i = 0; i < count; i++)
{
InteractionResultBuffer[i].Process(impactObject);
}
}
/// <summary>
/// Process a continuous interaction using the interaction data and the given Impact Object. The primary material at the interaction point will be used.
/// </summary>
/// <param name="interactionData">The interaction data to process.</param>
/// <param name="impactObject">The Impact Object that an Impact Material will be retrieved from.</param>
public void ProcessContinuousInteraction <T>(T interactionData, IImpactObject impactObject) where T : IInteractionData
{
ProcessContinuousInteraction(interactionData, impactObject.GetPrimaryMaterial(interactionData.Point), impactObject);
}
/// <summary>
/// Process a continuous interaction using the interaction data, an Impact Material, and an optional Impact Object that the interaction originated from.
/// </summary>
/// <param name="interactionData">The interaction data to process.</param>
/// <param name="impactMaterial">The Impact Material to get interaction results from.</param>
/// <param name="impactObject">An optional Impact Object that the interaction originated from.</param>
public void ProcessContinuousInteraction <T>(T interactionData, IImpactMaterial material, IImpactObject impactObject) where T : IInteractionData
{
int resultCount = material.GetInteractionResultsNonAlloc(interactionData, InteractionResultBuffer);
for (int i = 0; i < resultCount; i++)
{
IContinuousInteractionResult result = InteractionResultBuffer[i] as IContinuousInteractionResult;
//result is not a continuous interaction, so simply Process it.
if (result == null)
{
InteractionResultBuffer[i].Process(impactObject);
}
//Otherwise update an existing continuous interaction or add a new one.
else
{
AddOrUpdateContinuousInteractionResult(impactObject, result);
}
}
}
