private bool DoesParticleShareConstraints(IObiConstraints constraints, int index, List <int> particles, bool[] selected)
{
bool shared = false;
for (int i = 0; i < constraints.GetBatchCount(); ++i)
{
var batch = constraints.GetBatch(i);
for (int j = 0; j < batch.activeConstraintCount; ++j)
{
particles.Clear();
batch.GetParticlesInvolved(j, particles);
if (shared |= IsParticleSharedInConstraint(index, particles, selected))
{
break;
}
}
if (shared)
{
break;
}
}
return(shared);
}
// merges constraints from a given actor with this one.
public void Merge(ObiActor actor, IObiConstraints other)
{
var others = other as ObiConstraints <T>;
if (others == null || !other.GetConstraintType().HasValue)
{
return;
}
int constraintType = (int)other.GetConstraintType().Value;
// clear batch offsets for this constraint type:
actor.solverBatchOffsets[constraintType].Clear();
// create new empty batches if needed:
int newBatches = Mathf.Max(0, others.GetBatchCount() - GetBatchCount());
for (int i = 0; i < newBatches; ++i)
{
AddBatch(CreateBatch());
}
for (int i = 0; i < other.GetBatchCount(); ++i)
{
// store this batch's offset:
actor.solverBatchOffsets[constraintType].Add(batches[i].activeConstraintCount);
// merge both batches:
batches[i].Merge(actor, others.batches[i]);
}
}
public void AddToSolver(IObiConstraints constraints)
{
// create a constraint batch:
batch = Oni.CreateBatch((int)constraintType);
Oni.AddBatch(constraints.GetActor().solver.OniSolver, batch);
OnAddToSolver(constraints);
}
protected override void OnAddToSolver(IObiConstraints constraints)
{
for (int i = 0; i < particleIndices.count; i++)
{
particleIndices[i] = constraints.GetActor().solverIndices[source.particleIndices[i]];
}
// pass constraint data arrays to the solver:
Oni.SetChainConstraints(batch, particleIndices.GetIntPtr(), lengths.GetIntPtr(), firstParticle.GetIntPtr(), numParticles.GetIntPtr(), m_ConstraintCount);
Oni.SetActiveConstraints(batch, m_ActiveConstraintCount);
}
public void RemoveFromSolver(IObiConstraints constraints)
{
OnRemoveFromSolver(constraints);
// remove the constraint batch from the solver
// (no need to destroy it as its destruction is managed by the solver)
Oni.RemoveBatch(constraints.GetActor().solver.OniSolver, batch);
// important: set the batch pointer to null, as it could be destroyed by the solver.
batch = IntPtr.Zero;
}
protected override void OnAddToSolver(IObiConstraints constraints)
{
for (int i = 0; i < skinCompliance.count; i++)
{
particleIndices[i] = constraints.GetActor().solverIndices[source.particleIndices[i]];
}
// pass constraint data arrays to the solver:
Oni.SetSkinConstraints(batch, particleIndices.GetIntPtr(), skinPoints.GetIntPtr(), skinNormals.GetIntPtr(), skinRadiiBackstop.GetIntPtr(), skinCompliance.GetIntPtr(), m_ConstraintCount);
Oni.SetActiveConstraints(batch, m_ActiveConstraintCount);
}
protected override void OnAddToSolver(IObiConstraints constraints)
{
for (int i = 0; i < particleIndices.count; i++)
{
particleIndices[i] = constraints.GetActor().solverIndices[source.particleIndices[i]];
}
// pass constraint data arrays to the solver:
Oni.SetAerodynamicConstraints(batch, particleIndices.GetIntPtr(), aerodynamicCoeffs.GetIntPtr(), m_ConstraintCount);
Oni.SetActiveConstraints(batch, m_ActiveConstraintCount);
}
protected override void OnAddToSolver(IObiConstraints constraints)
{
for (int i = 0; i < stiffnesses.count; i++)
{
particleIndices[i * 2] = constraints.GetActor().solverIndices[source.particleIndices[i * 2]];
particleIndices[i * 2 + 1] = constraints.GetActor().solverIndices[source.particleIndices[i * 2 + 1]];
}
// pass constraint data arrays to the solver:
Oni.SetTetherConstraints(batch, particleIndices.GetIntPtr(), maxLengthsScales.GetIntPtr(), stiffnesses.GetIntPtr(), m_ConstraintCount);
Oni.SetActiveConstraints(batch, m_ActiveConstraintCount);
}
protected override void OnAddToSolver(IObiConstraints constraints)
{
for (int i = 0; i < particleIndices.count; i++)
{
particleIndices[i] = constraints.GetActor().solverIndices[source.particleIndices[i]];
}
// pass constraint data arrays to the solver:
Oni.SetVolumeConstraints(batch, particleIndices.GetIntPtr(), firstTriangle.GetIntPtr(),
restVolumes.GetIntPtr(), pressureStiffness.GetIntPtr(), m_ConstraintCount);
Oni.SetActiveConstraints(batch, m_ActiveConstraintCount);
}
public override IObiConstraintsBatch Clone(IObiConstraints constraints)
{
var clone = new ObiAerodynamicConstraintsBatch(constraints as ObiAerodynamicConstraintsData, this);
clone.particleIndices.ResizeUninitialized(particleIndices.count);
clone.aerodynamicCoeffs.ResizeUninitialized(aerodynamicCoeffs.count);
clone.particleIndices.CopyFrom(particleIndices);
clone.aerodynamicCoeffs.CopyFrom(aerodynamicCoeffs);
return(clone);
}
protected override void OnAddToSolver(IObiConstraints constraints)
{
for (int i = 0; i < restBends.count; i++)
{
particleIndices[i * 3] = constraints.GetActor().solverIndices[source.particleIndices[i * 3]];
particleIndices[i * 3 + 1] = constraints.GetActor().solverIndices[source.particleIndices[i * 3 + 1]];
particleIndices[i * 3 + 2] = constraints.GetActor().solverIndices[source.particleIndices[i * 3 + 2]];
}
// pass constraint data arrays to the solver:
Oni.SetBendingConstraints(batch, particleIndices.GetIntPtr(), restBends.GetIntPtr(), bendingStiffnesses.GetIntPtr(), m_ConstraintCount);
Oni.SetActiveConstraints(batch, m_ActiveConstraintCount);
}
protected override void OnAddToSolver(IObiConstraints constraints)
{
for (int i = 0; i < restLengths.count; i++)
{
particleIndices[i * 2] = constraints.GetActor().solverIndices[source.particleIndices[i * 2]];
particleIndices[i * 2 + 1] = constraints.GetActor().solverIndices[source.particleIndices[i * 2 + 1]];
stiffnesses[i] = new Vector2(0, restLengths[i]);
}
// pass constraint data arrays to the solver:
Oni.SetDistanceConstraints(batch, particleIndices.GetIntPtr(), restLengths.GetIntPtr(), stiffnesses.GetIntPtr(), m_ConstraintCount);
Oni.SetActiveConstraints(batch, m_ActiveConstraintCount);
}
protected override void OnAddToSolver(IObiConstraints constraints)
{
for (int i = 0; i < restLengths.count; i++)
{
particleIndices[i * 2] = constraints.GetActor().solverIndices[source.particleIndices[i * 2]];
particleIndices[i * 2 + 1] = constraints.GetActor().solverIndices[source.particleIndices[i * 2 + 1]];
orientationIndices[i] = constraints.GetActor().solverIndices[((ObiStretchShearConstraintsBatch)source).orientationIndices[i]];
}
// pass constraint data arrays to the solver:
Oni.SetStretchShearConstraints(batch, particleIndices.GetIntPtr(), orientationIndices.GetIntPtr(), restLengths.GetIntPtr(), restOrientations.GetIntPtr(), stiffnesses.GetIntPtr(), m_ConstraintCount);
Oni.SetActiveConstraints(batch, m_ActiveConstraintCount);
}
public override IObiConstraintsBatch Clone(IObiConstraints constraints)
{
var clone = new ObiDistanceConstraintsBatch(constraints as ObiDistanceConstraintsData, this);
clone.particleIndices.ResizeUninitialized(particleIndices.count);
clone.restLengths.ResizeUninitialized(restLengths.count);
clone.stiffnesses.ResizeUninitialized(stiffnesses.count);
clone.particleIndices.CopyFrom(particleIndices);
clone.restLengths.CopyFrom(restLengths);
clone.stiffnesses.CopyFrom(stiffnesses);
return(clone);
}
public override IObiConstraintsBatch Clone(IObiConstraints constraints)
{
var clone = new ObiTetherConstraintsBatch(constraints as ObiTetherConstraintsData, this);
clone.particleIndices.ResizeUninitialized(particleIndices.count);
clone.maxLengthsScales.ResizeUninitialized(maxLengthsScales.count);
clone.stiffnesses.ResizeUninitialized(stiffnesses.count);
clone.particleIndices.CopyFrom(particleIndices);
clone.maxLengthsScales.CopyFrom(maxLengthsScales);
clone.stiffnesses.CopyFrom(stiffnesses);
return(clone);
}
public override IObiConstraintsBatch Clone(IObiConstraints constraints)
{
var clone = new ObiBendTwistConstraintsBatch(constraints as ObiBendTwistConstraintsData, this);
clone.particleIndices.ResizeUninitialized(particleIndices.count);
clone.restDarbouxVectors.ResizeUninitialized(restDarbouxVectors.count);
clone.stiffnesses.ResizeUninitialized(stiffnesses.count);
clone.particleIndices.CopyFrom(particleIndices);
clone.restDarbouxVectors.CopyFrom(restDarbouxVectors);
clone.stiffnesses.CopyFrom(stiffnesses);
return(clone);
}
public override IObiConstraintsBatch Clone(IObiConstraints constraints)
{
var clone = new ObiBendConstraintsBatch(constraints as ObiBendConstraintsData, this);
clone.particleIndices.ResizeUninitialized(particleIndices.count);
clone.restBends.ResizeUninitialized(restBends.count);
clone.bendingStiffnesses.ResizeUninitialized(bendingStiffnesses.count);
clone.particleIndices.CopyFrom(particleIndices);
clone.restBends.CopyFrom(restBends);
clone.bendingStiffnesses.CopyFrom(bendingStiffnesses);
return(clone);
}
public override IObiConstraintsBatch Clone(IObiConstraints constraints)
{
var clone = new ObiVolumeConstraintsBatch(constraints as ObiVolumeConstraintsData, this);
clone.particleIndices.ResizeUninitialized(particleIndices.count);
clone.firstTriangle.ResizeUninitialized(firstTriangle.count);
clone.restVolumes.ResizeUninitialized(restVolumes.count);
clone.pressureStiffness.ResizeUninitialized(pressureStiffness.count);
clone.particleIndices.CopyFrom(particleIndices);
clone.firstTriangle.CopyFrom(firstTriangle);
clone.restVolumes.CopyFrom(restVolumes);
clone.pressureStiffness.CopyFrom(pressureStiffness);
return(clone);
}
protected override void OnAddToSolver(IObiConstraints constraints)
{
if (source != null)
{
for (int i = 0; i < particleIndices.count; i++)
{
particleIndices[i] = constraints.GetActor().solverIndices[source.particleIndices[i]];
stiffnesses[i * 2] = 0;
stiffnesses[i * 2 + 1] = 0;
}
}
// pass constraint data arrays to the solver:
Oni.SetPinConstraints(batch, particleIndices.GetIntPtr(), offsets.GetIntPtr(), restDarbouxVectors.GetIntPtr(), pinBodies.GetIntPtr(), stiffnesses.GetIntPtr(), m_ConstraintCount);
Oni.SetActiveConstraints(batch, m_ActiveConstraintCount);
}
public override IObiConstraintsBatch Clone(IObiConstraints constraints)
{
var clone = new ObiChainConstraintsBatch(constraints as ObiChainConstraintsData, this);
clone.particleIndices.ResizeUninitialized(particleIndices.count);
clone.firstParticle.ResizeUninitialized(firstParticle.count);
clone.numParticles.ResizeUninitialized(numParticles.count);
clone.lengths.ResizeUninitialized(lengths.count);
clone.particleIndices.CopyFrom(particleIndices);
clone.firstParticle.CopyFrom(firstParticle);
clone.numParticles.CopyFrom(numParticles);
clone.lengths.CopyFrom(lengths);
return(clone);
}
public override IObiConstraintsBatch Clone(IObiConstraints constraints)
{
var clone = new ObiSkinConstraintsBatch(constraints as ObiSkinConstraintsData, this);
clone.particleIndices.ResizeUninitialized(particleIndices.count);
clone.skinPoints.ResizeUninitialized(skinPoints.count);
clone.skinNormals.ResizeUninitialized(skinNormals.count);
clone.skinRadiiBackstop.ResizeUninitialized(skinRadiiBackstop.count);
clone.skinCompliance.ResizeUninitialized(skinCompliance.count);
clone.particleIndices.CopyFrom(particleIndices);
clone.skinPoints.CopyFrom(skinPoints);
clone.skinNormals.CopyFrom(skinNormals);
clone.skinRadiiBackstop.CopyFrom(skinRadiiBackstop);
clone.skinCompliance.CopyFrom(skinCompliance);
return(clone);
}
private void DeactivateConstraintsWithInactiveParticles(IObiConstraints constraints, List <int> particles)
{
foreach (var batch in constraints.GetBatchInterfaces())
{
for (int i = batch.activeConstraintCount - 1; i >= 0; --i)
{
particles.Clear();
batch.GetParticlesInvolved(i, particles);
for (int k = 0; k < particles.Count; ++k)
{
if (!IsParticleActive(particles[k]))
{
batch.DeactivateConstraint(i);
break;
}
}
}
}
}
protected override void OnAddToSolver(IObiConstraints constraints)
{
for (int i = 0; i < particleIndices.count; i++)
{
particleIndices[i] = constraints.GetActor().solverIndices[source.particleIndices[i]];
}
for (int i = 0; i < orientations.count; i++)
{
orientations[i] = constraints.GetActor().actorLocalToSolverMatrix.rotation;
}
// pass constraint data arrays to the solver:
Oni.SetShapeMatchingConstraints(batch, particleIndices.GetIntPtr(), firstIndex.GetIntPtr(), numIndices.GetIntPtr(), explicitGroup.GetIntPtr(),
materialParameters.GetIntPtr(), restComs.GetIntPtr(), coms.GetIntPtr(), orientations.GetIntPtr(), m_ConstraintCount);
Oni.SetActiveConstraints(batch, m_ActiveConstraintCount);
Oni.CalculateRestShapeMatching(constraints.GetActor().solver.OniSolver, batch);
}
private void LoadBlueprintConstraints(ObiActorBlueprint bp)
{
m_Constraints = new IObiConstraints[Oni.ConstraintTypeCount];
// Iterate trough all non-null constraint types in the blueprint that have at least 1 batch:
foreach (IObiConstraints constraintData in bp.GetConstraints())
{
// Create runtime counterpart
IObiConstraints runtimeConstraints = constraintData.Clone(this);
if (runtimeConstraints.GetConstraintType().HasValue)
{
// Store a reference to it in the constraint map, so that they can be accessed by type enum:
m_Constraints[(int)runtimeConstraints.GetConstraintType().Value] = runtimeConstraints;
// Add it to solver:
runtimeConstraints.AddToSolver();
}
}
}
public override IObiConstraintsBatch Clone(IObiConstraints constraints)
{
var clone = new ObiShapeMatchingConstraintsBatch(constraints as ObiShapeMatchingConstraintsData, this);
clone.particleIndices.ResizeUninitialized(particleIndices.count);
clone.firstIndex.ResizeUninitialized(firstIndex.count);
clone.numIndices.ResizeUninitialized(numIndices.count);
clone.explicitGroup.ResizeUninitialized(explicitGroup.count);
clone.materialParameters.ResizeUninitialized(materialParameters.count);
clone.particleIndices.CopyFrom(particleIndices);
clone.firstIndex.CopyFrom(firstIndex);
clone.numIndices.CopyFrom(numIndices);
clone.explicitGroup.CopyFrom(explicitGroup);
clone.materialParameters.CopyFrom(materialParameters);
clone.restComs.ResizeUninitialized(constraintCount);
clone.coms.ResizeUninitialized(constraintCount);
clone.orientations.ResizeUninitialized(constraintCount);
return(clone);
}
public override IObiConstraintsBatch Clone(IObiConstraints constraints)
{
var clone = new ObiPinConstraintsBatch(constraints as ObiPinConstraintsData, this);
// careful here: since IntPtr is not serializable and the pinBodies array can be null, use offsets count instead.
clone.pinBodies.Capacity = offsets.count;
clone.pinBodies.Clear();
if (pinBodies != null)
{
for (int i = 0; i < offsets.count; ++i)
{
clone.pinBodies.Add(pinBodies[i]);
}
}
else
{
for (int i = 0; i < offsets.count; ++i)
{
clone.pinBodies.Add(new ObiColliderHandle());
}
}
clone.particleIndices.ResizeUninitialized(particleIndices.count);
clone.offsets.ResizeUninitialized(offsets.count);
clone.restDarbouxVectors.ResizeUninitialized(restDarbouxVectors.count);
clone.stiffnesses.ResizeUninitialized(stiffnesses.count);
clone.breakThresholds.ResizeUninitialized(breakThresholds.count);
clone.particleIndices.CopyFrom(particleIndices);
clone.offsets.CopyFrom(offsets);
clone.restDarbouxVectors.CopyFrom(restDarbouxVectors);
clone.stiffnesses.CopyFrom(stiffnesses);
clone.breakThresholds.CopyFrom(breakThresholds);
return(clone);
}
public abstract IObiConstraintsBatch Clone(IObiConstraints constraints);
protected virtual void OnAddToSolver(IObiConstraints constraints)
{
}
protected virtual void OnRemoveFromSolver(IObiConstraints constraints)
{
}
