public Relation(Network net, Variable v0, bool[][] rel, Variable v1, ConstraintTypes cType, int weight)
: base(net, cType, weight)
{
_rel = rel;
_v0 = v0;
_v1 = v1;
}
public static string ConstraintFormat(ConstraintTypes constraintType)
{
string retVal = string.Empty;
switch (constraintType)
{
case ConstraintTypes.PrimaryKey:
retVal = "Constraint {0} Primary Key({1})";
break;
case ConstraintTypes.ForeignKey:
break;
case ConstraintTypes.Default:
retVal = "Default {0}";
break;
case ConstraintTypes.Check:
retVal = "Check {0}";
break;
case ConstraintTypes.Unique:
retVal = "Unique";
break;
default:
break;
}
return(retVal);
}
/// <summary>
/// Returns the string with all constraints as defined in code
/// </summary>
/// <returns>String with all constraints as defined in code</returns>
public string GetConstraintsString()
{
if (!HasAnyConstraint)
{
return(null);
}
var items = new List <string>();
if (HasReferenceTypeConstraint)
{
items.Add("class");
}
if (HasUnmanagedTypeConstraint)
{
items.Add("unmanaged");
}
if (HasValueTypeConstraint)
{
items.Add("struct");
}
if (ConstraintTypes != null)
{
items.AddRange(ConstraintTypes.Select(ct => ct.Name));
}
if (HasConstructorConstraint)
{
items.Add("new()");
}
return($" where {Name}: {string.Join(", ", items)}");
}
public Relation(Network net, Variable v0, bool[][] rel, Variable v1, ConstraintTypes cType, int weight)
: base(net, cType, weight)
{
this.rel = rel;
this.v0 = v0;
this.v1 = v1;
}
/// <summary> Constructor.
/// (for invocation by subclass constructors, typically implicit)
/// </summary>
protected internal Constraint(Network net, ConstraintTypes cType)
{
Network = net;
Index = -1;
Network.ADD(this);
CType = cType;
}
public Element(Network net, Variable v0, Variable v1, Variable[] v, ConstraintTypes cType, int weight)
: base(net, cType, weight)
{
_v0 = v0;
_v1 = v1;
_v = (Variable[])v.Clone();
}
public Element(Network net, Variable v0, Variable v1, Variable[] v, ConstraintTypes cType, int weight)
: base(net, cType, weight)
{
this.v0 = v0;
this.v1 = v1;
this.v = (Variable[])v.Clone();
}
/// <summary> Constructor.
/// (for invocation by subclass constructors, typically implicit)
/// </summary>
protected internal Constraint(Network net, ConstraintTypes cType)
{
Network = net;
Index = -1;
Network.ADD(this);
CType = cType;
}
/// <summary> Constructor.
/// (for invocation by subclass constructors, typically implicit)
/// </summary>
protected internal Constraint(Network net, ConstraintTypes cType, int weight)
{
Network = net;
Index = -1;
Weight = weight;
Network.ADD(this);
CType = cType;
}
/// <summary> Constructor.
/// (for invocation by subclass constructors, typically implicit)
/// </summary>
protected internal Constraint(Network net, ConstraintTypes cType, int weight)
{
Network = net;
Index = -1;
Weight = weight;
Network.ADD(this);
CType = cType;
}
public Sequential(Network net, Variable[] v, int[] l, ConstraintTypes cType, int weight)
: base(net, cType, weight)
{
this.v = new Variable[v.Length];
v.CopyTo(this.v, 0);
this.l = new int[l.Length];
l.CopyTo(this.l, 0);
}
public Sequential(Network net, Variable[] v, int[] l, ConstraintTypes cType, int weight)
: base(net, cType, weight)
{
_v = new Variable[v.Length];
v.CopyTo(_v, 0);
_l = new int[l.Length];
l.CopyTo(_l, 0);
}
public void AddConstraint(ConstraintTypes constraintType, double rhs, params double[] coefficients)
{
double[] coeff = new double[coefficients.Length + 1];
coefficients.CopyTo(coeff, 1);
if (!lpsolve32.add_constraint(_id, coeff, constraintType, rhs))
{
throw new Exception();
}
}
public void PopulateModel(IDataReader dr)
{
if (dr.ColumnIsNotNull("TableName"))
{
TableName = Convert.ToString(dr["TableName"]);
}
if (dr.ColumnIsNotNull("ColumnName"))
{
ColumnName = Convert.ToString(dr["ColumnName"]);
}
if (dr.ColumnIsNotNull("ConstraintName"))
{
ConstraintName = Convert.ToString(dr["ConstraintName"]);
}
if (dr.ColumnIsNotNull("ConstraintType"))
{
var constraintType = Convert.ToString(dr["ConstraintType"]);
switch (constraintType.ToUpper())
{
case ByPrimaryKeyConstraintType:
ConstraintType = ConstraintTypes.PrimaryKey;
break;
case ByForeignKeyConstraintType:
ConstraintType = ConstraintTypes.ForeignKey;
break;
case ByIndexConstraintType:
ConstraintType = ConstraintTypes.Index;
break;
case ByNotNullConstraintType:
ConstraintType = ConstraintTypes.NotNull;
break;
case ByUniqueConstraintType:
ConstraintType = ConstraintTypes.Unique;
break;
case ByCheckConstraintType:
ConstraintType = ConstraintTypes.Check;
break;
case DefaultConstraintType:
ConstraintType = ConstraintTypes.Default;
break;
}
}
}
public Equals(Network net, Variable[] v, ConstraintTypes cType)
: this(net, v, cType, 0)
{
}
private IntComparison(Network net, int comp, Variable[] v, ConstraintTypes cType)
: this(net, comp, v, cType, 0)
{
}
public static ConstraintBase Create(ConstraintTypes constraint)
{
switch (constraint)
{
case ConstraintTypes.None:
return(null);
case ConstraintTypes.ArcRadius:
return(new ArcRadius());
case ConstraintTypes.ArcRules:
return(new ArcRules());
case ConstraintTypes.P2LDistance:
return(new P2LDistance());
case ConstraintTypes.P2PDistance:
return(new P2PDistance());
case ConstraintTypes.P2PDistanceHorz:
return(new P2PDistanceHorz());
case ConstraintTypes.P2PDistanceVert:
return(new P2PDistanceVert());
case ConstraintTypes.PointOnLine:
return(new PointOnLine());
case ConstraintTypes.PointOnPoint:
return(new PointOnPoint());
case ConstraintTypes.SymmetricPoints:
return(new SymmetricPoints());
case ConstraintTypes.PointOnArc:
return(new PointOnArc());
case ConstraintTypes.Horizontal:
return(new Horizontal());
case ConstraintTypes.CircleRadius:
return(new CircleRadius());
case ConstraintTypes.Vertical:
return(new Vertical());
case ConstraintTypes.InternalAngle:
return(new InternalAngle());
case ConstraintTypes.ExternalAngle:
return(new ExternalAngle());
case ConstraintTypes.TangentToArc:
return(new TangentToArc());
case ConstraintTypes.TangentToCircle:
return(new TangentToCircle());
case ConstraintTypes.LineLength:
return(new LineLength());
case ConstraintTypes.EqualLegnth:
return(new EqualLegnth());
case ConstraintTypes.P2LDistanceVert:
return(new P2LDistanceVert());
case ConstraintTypes.P2LDistanceHorz:
return(new P2LDistanceHorz());
case ConstraintTypes.EqualRadiusArcs:
return(new EqualRadiusArcs());
case ConstraintTypes.EqualRadiusCircles:
return(new EqualRadiusCircles());
case ConstraintTypes.EqualRadiusCircArc:
return(new EqualRadiusCircArc());
case ConstraintTypes.ConcentricArcs:
return(new ConcentricArcs());
case ConstraintTypes.ConcentricCircles:
return(new ConcentricCircles());
case ConstraintTypes.ConcentricCircArc:
return(new ConcentricCircArc());
case ConstraintTypes.Parallel:
return(new Parallel());
case ConstraintTypes.Colinear:
return(new Colinear());
case ConstraintTypes.Perpendicular:
return(new Perpendicular());
case ConstraintTypes.PointOnCircle:
return(new PointOnCircle());
case ConstraintTypes.PointOnLineMidpoint:
return(new PointOnLineMidpoint());
}
return(null);
}
public Count(Network net, ConstraintTypes cType)
: base(net, cType)
{
}
private IntArith(Network net, int a, Variable[] v, ConstraintTypes cType, int weight)
: base(net, cType, weight)
{
arith = a;
this.v = v;
}
public IntComparison(Network net, int comp, Variable v0, Variable v1, ConstraintTypes cType, int weight)
: this(net, comp, new[] { v0, v1 }, cType, weight)
{
}
private IntComparison(Network net, int comp, Variable[] v, ConstraintTypes cType, int weight)
: base(net, cType, weight)
{
_comparison = comp;
_v = v;
}
private IntArith(Network net, int a, Variable[] v, ConstraintTypes cType = ConstraintTypes.Hard)
: this(net, a, v, cType, 0)
{
}
/// <summary>
/// Creates the constraint.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="rigidBodyA">The rigid body a.</param>
/// <param name="frameA">The frame a.</param>
/// <param name="useReferenceFrameA">if set to <c>true</c> [use reference frame a].</param>
/// <returns></returns>
/// <exception cref="System.Exception">
/// Cannot perform this action when the physics engine is set to CollisionsOnly
/// or
/// Both RigidBodies must be valid
/// or
/// A Gear constraint always needs two rigidbodies to be created.
/// </exception>
public static Constraint CreateConstraint(ConstraintTypes type, RigidBody rigidBodyA, Matrix frameA, bool useReferenceFrameA = false)
{
if (rigidBodyA == null)
{
throw new Exception("Both RigidBodies must be valid");
}
var rbA = rigidBodyA.InternalRigidBody;
switch (type)
{
case ConstraintTypes.Point2Point:
{
var constraint = new Point2PointConstraint
{
InternalPoint2PointConstraint = new BulletSharp.Point2PointConstraint(rbA, frameA.TranslationVector),
RigidBodyA = rigidBodyA,
};
constraint.InternalConstraint = constraint.InternalPoint2PointConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.Hinge:
{
var constraint = new HingeConstraint
{
InternalHingeConstraint = new BulletSharp.HingeConstraint(rbA, frameA, useReferenceFrameA),
RigidBodyA = rigidBodyA,
};
constraint.InternalConstraint = constraint.InternalHingeConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.Slider:
{
var constraint = new SliderConstraint
{
InternalSliderConstraint = new BulletSharp.SliderConstraint(rbA, frameA, useReferenceFrameA),
RigidBodyA = rigidBodyA,
};
constraint.InternalConstraint = constraint.InternalSliderConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.ConeTwist:
{
var constraint = new ConeTwistConstraint
{
InternalConeTwistConstraint = new BulletSharp.ConeTwistConstraint(rbA, frameA),
RigidBodyA = rigidBodyA
};
constraint.InternalConstraint = constraint.InternalConeTwistConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.Generic6DoF:
{
var constraint = new Generic6DoFConstraint
{
InternalGeneric6DofConstraint = new BulletSharp.Generic6DofConstraint(rbA, frameA, useReferenceFrameA),
RigidBodyA = rigidBodyA
};
constraint.InternalConstraint = constraint.InternalGeneric6DofConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.Generic6DoFSpring:
{
var constraint = new Generic6DoFSpringConstraint
{
InternalGeneric6DofSpringConstraint = new BulletSharp.Generic6DofSpringConstraint(rbA, frameA, useReferenceFrameA),
RigidBodyA = rigidBodyA
};
constraint.InternalConstraint = constraint.InternalGeneric6DofConstraint = constraint.InternalGeneric6DofSpringConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.Gear:
{
throw new Exception("A Gear constraint always needs two rigidbodies to be created.");
}
}
return(null);
}
public IntArith(Network net, int a, Variable v0, Variable v1, Variable v2, ConstraintTypes cType, int weight)
: this(net, a, new[] { v0, v1, v2 }, cType, weight)
{
}
public IntArith(Network net, int a, Variable v0, int x1, Variable v2, ConstraintTypes cType, int weight)
: this(net, a, v0, new IntVariable(net, x1), v2, cType, weight)
{
}
public void Equals(IntVariable v, ConstraintTypes cType)
{
Equals(v, cType, 0);
}
public IntArith(Network net, int a, Variable v0, int x1, Variable v2, ConstraintTypes cType, int weight)
: this(net, a, v0, new IntVariable(net, x1), v2, cType, weight)
{
}
public IntArith(Network net, int a, int x0, Variable v1, Variable v2, ConstraintTypes cType, int weight)
: this(net, a, new IntVariable(net, x0), v1, v2, cType, weight)
{
}
public IntArith(Network net, int a, Variable v0, Variable v1, Variable v2, ConstraintTypes cType, int weight)
: this(net, a, new[] { v0, v1, v2 }, cType, weight)
{
}
public IntArith(Network net, int a, Variable v0, Variable v1, int x2, ConstraintTypes cType, int weight)
: this(net, a, v0, v1, new IntVariable(net, x2), cType, weight)
{
}
public IntComparison(Network net, int comp, int x0, Variable v1, ConstraintTypes cType)
: this(net, comp, new IntVariable(net, x0), v1, cType)
{
}
public Serialized(Network net, Variable[] v, int[] l, ConstraintTypes cType)
: this(net, v, l, cType, 0)
{
}
private IntComparison(Network net, int comp, Variable[] v, ConstraintTypes cType)
: this(net, comp, v, cType, 0)
{
}
/// <summary>
/// Creates the constraint.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="rigidBodyA">The rigid body a.</param>
/// <param name="rigidBodyB">The rigid body b.</param>
/// <param name="frameA">The frame a.</param>
/// <param name="frameB">The frame b.</param>
/// <param name="useReferenceFrameA">if set to <c>true</c> [use reference frame a].</param>
/// <returns></returns>
/// <exception cref="System.Exception">
/// Cannot perform this action when the physics engine is set to CollisionsOnly
/// or
/// Both RigidBodies must be valid
/// </exception>
public static Constraint CreateConstraint(ConstraintTypes type, RigidbodyComponent rigidBodyA, RigidbodyComponent rigidBodyB, Matrix frameA, Matrix frameB, bool useReferenceFrameA = false)
{
if (rigidBodyA == null || rigidBodyB == null) throw new Exception("Both RigidBodies must be valid");
//todo check if the 2 rbs are on the same engine instance!
var rbA = rigidBodyA.InternalRigidBody;
var rbB = rigidBodyB.InternalRigidBody;
switch (type)
{
case ConstraintTypes.Point2Point:
{
var constraint = new Point2PointConstraint
{
InternalPoint2PointConstraint = new BulletSharp.Point2PointConstraint(rbA, rbB, frameA.TranslationVector, frameB.TranslationVector),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalPoint2PointConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.Hinge:
{
var constraint = new HingeConstraint
{
InternalHingeConstraint = new BulletSharp.HingeConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalHingeConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.Slider:
{
var constraint = new SliderConstraint
{
InternalSliderConstraint = new BulletSharp.SliderConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalSliderConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.ConeTwist:
{
var constraint = new ConeTwistConstraint
{
InternalConeTwistConstraint = new BulletSharp.ConeTwistConstraint(rbA, rbB, frameA, frameB),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalConeTwistConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.Generic6DoF:
{
var constraint = new Generic6DoFConstraint
{
InternalGeneric6DofConstraint = new BulletSharp.Generic6DofConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalGeneric6DofConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.Generic6DoFSpring:
{
var constraint = new Generic6DoFSpringConstraint
{
InternalGeneric6DofSpringConstraint = new BulletSharp.Generic6DofSpringConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalGeneric6DofConstraint = constraint.InternalGeneric6DofSpringConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.Gear:
{
var constraint = new GearConstraint
{
InternalGearConstraint = new BulletSharp.GearConstraint(rbA, rbB, frameA.TranslationVector, frameB.TranslationVector),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalGearConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return constraint;
}
}
return null;
}
public Count(Network net, Variable[] v, ConstraintTypes cType)
: base(net, cType)
{
this.v = new Variable[v.Length];
v.CopyTo(this.v, 0);
}
public IntComparison(Network net, int comp, Variable v0, int x1, ConstraintTypes cType, int weight)
: this(net, comp, v0, new IntVariable(net, x1), cType, weight)
{
}
public virtual void Ge(IntVariable v, ConstraintTypes cType)
{
Ge(v, cType, 0);
}
/// <summary>
/// Creates the constraint.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="rigidBodyA">The rigid body a.</param>
/// <param name="rigidBodyB">The rigid body b.</param>
/// <param name="frameA">The frame a.</param>
/// <param name="frameB">The frame b.</param>
/// <param name="useReferenceFrameA">if set to <c>true</c> [use reference frame a].</param>
/// <returns></returns>
/// <exception cref="System.Exception">
/// Cannot perform this action when the physics engine is set to CollisionsOnly
/// or
/// Both RigidBodies must be valid
/// </exception>
public Constraint CreateConstraint(ConstraintTypes type, RigidBody rigidBodyA, RigidBody rigidBodyB, Matrix frameA, Matrix frameB, bool useReferenceFrameA = false)
{
if (discreteDynamicsWorld == null)
{
throw new Exception("Cannot perform this action when the physics engine is set to CollisionsOnly");
}
if (rigidBodyA == null || rigidBodyB == null)
{
throw new Exception("Both RigidBodies must be valid");
}
var rbA = rigidBodyA.InternalRigidBody;
var rbB = rigidBodyB.InternalRigidBody;
switch (type)
{
case ConstraintTypes.Point2Point:
{
var constraint = new Point2PointConstraint
{
InternalPoint2PointConstraint = new BulletSharp.Point2PointConstraint(rbA, rbB, frameA.TranslationVector, frameB.TranslationVector),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalPoint2PointConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
constraint.Engine = this;
return(constraint);
}
case ConstraintTypes.Hinge:
{
var constraint = new HingeConstraint
{
InternalHingeConstraint = new BulletSharp.HingeConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalHingeConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
constraint.Engine = this;
return(constraint);
}
case ConstraintTypes.Slider:
{
var constraint = new SliderConstraint
{
InternalSliderConstraint = new BulletSharp.SliderConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalSliderConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
constraint.Engine = this;
return(constraint);
}
case ConstraintTypes.ConeTwist:
{
var constraint = new ConeTwistConstraint
{
InternalConeTwistConstraint = new BulletSharp.ConeTwistConstraint(rbA, rbB, frameA, frameB),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalConeTwistConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
constraint.Engine = this;
return(constraint);
}
case ConstraintTypes.Generic6DoF:
{
var constraint = new Generic6DoFConstraint
{
InternalGeneric6DofConstraint = new BulletSharp.Generic6DofConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalGeneric6DofConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
constraint.Engine = this;
return(constraint);
}
case ConstraintTypes.Generic6DoFSpring:
{
var constraint = new Generic6DoFSpringConstraint
{
InternalGeneric6DofSpringConstraint = new BulletSharp.Generic6DofSpringConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalGeneric6DofConstraint = constraint.InternalGeneric6DofSpringConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
constraint.Engine = this;
return(constraint);
}
case ConstraintTypes.Gear:
{
var constraint = new GearConstraint
{
InternalGearConstraint = new BulletSharp.GearConstraint(rbA, rbB, frameA.TranslationVector, frameB.TranslationVector),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalGearConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
constraint.Engine = this;
return(constraint);
}
}
return(null);
}
public IntArith(Network net, int a, Variable v0, Variable v1, int x2, ConstraintTypes cType, int weight)
: this(net, a, v0, v1, new IntVariable(net, x2), cType, weight)
{
}
public virtual void Ge(int value, ConstraintTypes cType)
{
Ge(value, cType, 0);
}
public IntArith(Network net, int a, int x0, Variable v1, Variable v2, ConstraintTypes cType, int weight)
: this(net, a, new IntVariable(net, x0), v1, v2, cType, weight)
{
}
public virtual void Ge(ConstraintTypes cType, int weight)
{
Ge(0, cType, weight);
}
private IntArith(Network net, int a, Variable[] v, ConstraintTypes cType, int weight)
: base(net, cType, weight)
{
_arith = a;
_v = v;
}
public virtual void Lt(IntVariable v, ConstraintTypes cType)
{
Lt(v, cType, 0);
}
/// <summary>
/// Creates the constraint.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="rigidBodyA">The rigid body a.</param>
/// <param name="rigidBodyB">The rigid body b.</param>
/// <param name="frameA">The frame a.</param>
/// <param name="frameB">The frame b.</param>
/// <param name="useReferenceFrameA">if set to <c>true</c> [use reference frame a].</param>
/// <returns></returns>
/// <exception cref="System.Exception">
/// Cannot perform this action when the physics engine is set to CollisionsOnly
/// or
/// Both RigidBodies must be valid
/// </exception>
public static Constraint CreateConstraint(ConstraintTypes type, RigidBody rigidBodyA, RigidBody rigidBodyB, Matrix frameA, Matrix frameB, bool useReferenceFrameA = false)
{
if (rigidBodyA == null || rigidBodyB == null)
{
throw new Exception("Both RigidBodies must be valid");
}
//todo check if the 2 rbs are on the same engine instance!
var rbA = rigidBodyA.InternalRigidBody;
var rbB = rigidBodyB.InternalRigidBody;
switch (type)
{
case ConstraintTypes.Point2Point:
{
var constraint = new Point2PointConstraint
{
InternalPoint2PointConstraint = new BulletSharp.Point2PointConstraint(rbA, rbB, frameA.TranslationVector, frameB.TranslationVector),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalPoint2PointConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.Hinge:
{
var constraint = new HingeConstraint
{
InternalHingeConstraint = new BulletSharp.HingeConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalHingeConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.Slider:
{
var constraint = new SliderConstraint
{
InternalSliderConstraint = new BulletSharp.SliderConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalSliderConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.ConeTwist:
{
var constraint = new ConeTwistConstraint
{
InternalConeTwistConstraint = new BulletSharp.ConeTwistConstraint(rbA, rbB, frameA, frameB),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalConeTwistConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.Generic6DoF:
{
var constraint = new Generic6DoFConstraint
{
InternalGeneric6DofConstraint = new BulletSharp.Generic6DofConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalGeneric6DofConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.Generic6DoFSpring:
{
var constraint = new Generic6DoFSpringConstraint
{
InternalGeneric6DofSpringConstraint = new BulletSharp.Generic6DofSpringConstraint(rbA, rbB, frameA, frameB, useReferenceFrameA),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalGeneric6DofConstraint = constraint.InternalGeneric6DofSpringConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return(constraint);
}
case ConstraintTypes.Gear:
{
var constraint = new GearConstraint
{
InternalGearConstraint = new BulletSharp.GearConstraint(rbA, rbB, frameA.TranslationVector, frameB.TranslationVector),
RigidBodyA = rigidBodyA,
RigidBodyB = rigidBodyB
};
constraint.InternalConstraint = constraint.InternalGearConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
rigidBodyB.LinkedConstraints.Add(constraint);
return(constraint);
}
}
return(null);
}
public virtual void Lt(IntVariable v, ConstraintTypes cType, int weight)
{
Network net = Network;
new IntComparison(net, IntComparison.Lt, this, v, cType, weight);
}
public ConstraintPrototype(ConstraintTypes type, dynamic value)
{
Type = type;
Value = value;
}
public virtual void Lt(int value, ConstraintTypes cType)
{
Lt(value, cType, 0);
}
/// <summary>
/// Creates the constraint.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="rigidBodyA">The rigid body a.</param>
/// <param name="frameA">The frame a.</param>
/// <param name="useReferenceFrameA">if set to <c>true</c> [use reference frame a].</param>
/// <returns></returns>
/// <exception cref="System.Exception">
/// Cannot perform this action when the physics engine is set to CollisionsOnly
/// or
/// Both RigidBodies must be valid
/// or
/// A Gear constraint always needs two rigidbodies to be created.
/// </exception>
public static Constraint CreateConstraint(ConstraintTypes type, RigidbodyComponent rigidBodyA, Matrix frameA, bool useReferenceFrameA = false)
{
if (rigidBodyA == null) throw new Exception("Both RigidBodies must be valid");
var rbA = rigidBodyA.InternalRigidBody;
switch (type)
{
case ConstraintTypes.Point2Point:
{
var constraint = new Point2PointConstraint
{
InternalPoint2PointConstraint = new BulletSharp.Point2PointConstraint(rbA, frameA.TranslationVector),
RigidBodyA = rigidBodyA,
};
constraint.InternalConstraint = constraint.InternalPoint2PointConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.Hinge:
{
var constraint = new HingeConstraint
{
InternalHingeConstraint = new BulletSharp.HingeConstraint(rbA, frameA, useReferenceFrameA),
RigidBodyA = rigidBodyA,
};
constraint.InternalConstraint = constraint.InternalHingeConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.Slider:
{
var constraint = new SliderConstraint
{
InternalSliderConstraint = new BulletSharp.SliderConstraint(rbA, frameA, useReferenceFrameA),
RigidBodyA = rigidBodyA,
};
constraint.InternalConstraint = constraint.InternalSliderConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.ConeTwist:
{
var constraint = new ConeTwistConstraint
{
InternalConeTwistConstraint = new BulletSharp.ConeTwistConstraint(rbA, frameA),
RigidBodyA = rigidBodyA
};
constraint.InternalConstraint = constraint.InternalConeTwistConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.Generic6DoF:
{
var constraint = new Generic6DoFConstraint
{
InternalGeneric6DofConstraint = new BulletSharp.Generic6DofConstraint(rbA, frameA, useReferenceFrameA),
RigidBodyA = rigidBodyA
};
constraint.InternalConstraint = constraint.InternalGeneric6DofConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.Generic6DoFSpring:
{
var constraint = new Generic6DoFSpringConstraint
{
InternalGeneric6DofSpringConstraint = new BulletSharp.Generic6DofSpringConstraint(rbA, frameA, useReferenceFrameA),
RigidBodyA = rigidBodyA
};
constraint.InternalConstraint = constraint.InternalGeneric6DofConstraint = constraint.InternalGeneric6DofSpringConstraint;
rigidBodyA.LinkedConstraints.Add(constraint);
return constraint;
}
case ConstraintTypes.Gear:
{
throw new Exception("A Gear constraint always needs two rigidbodies to be created.");
}
}
return null;
}
public virtual void Lt(int value, ConstraintTypes cType, int weight)
{
Network net = Network;
new IntComparison(net, IntComparison.Lt, this, new IntVariable(net, value), cType, weight);
}
public IntComparison(Network net, int comp, Variable v0, Variable v1, ConstraintTypes cType, int weight)
: this(net, comp, new[] { v0, v1 }, cType, weight)
{
}
public virtual void NotEquals(IntVariable v, ConstraintTypes cType)
{
NotEquals(v, cType, 0);
}
public IntComparison(Network net, int comp, int x0, Variable v1, ConstraintTypes cType, int weight)
: this(net, comp, new IntVariable(net, x0), v1, cType, weight)
{
}
public virtual void NotEquals(IntVariable v, ConstraintTypes cType, int weight)
{
Network net = Network;
new NotEquals(net, this, v, cType, weight);
}
private IntComparison(Network net, int comp, Variable[] v, ConstraintTypes cType, int weight)
: base(net, cType, weight)
{
comparison = comp;
this.v = v;
}
public virtual void NotEquals(int value, ConstraintTypes cType)
{
NotEquals(value, cType, 0);
}
public Equals(Network net, Variable v0, Variable v1, ConstraintTypes cType, int weight)
: this(net, new[] { v0, v1 }, cType, weight)
{
}
public virtual void NotEquals(int value, ConstraintTypes cType, int weight)
{
Network net = Network;
new NotEquals(net, this, new IntVariable(net, value), cType, weight);
}
public Equals(Network net, Variable[] v, ConstraintTypes cType, int weight)
: base(net, cType, weight)
{
this.v = new Variable[v.Length];
v.CopyTo(this.v, 0);
}
public IntComparison(Network net, int comp, Variable v0, int x1, ConstraintTypes cType)
: this(net, comp, v0, new IntVariable(net, x1), cType)
{
}
