public virtual void Transform(IUnitTransformation transform, TransformFlags flags)
{
foreach (var t in Vertices)
{
t.Location = transform.Transform(t.Location);
}
Plane = new Plane(Vertices[0].Location, Vertices[1].Location, Vertices[2].Location);
Colour = Colour;
if (flags.HasFlag(TransformFlags.TextureScalingLock) && Texture.Texture != null)
{
// Make a best-effort guess of retaining scaling. All bets are off during skew operations.
// Transform the current texture axes
var origin = transform.Transform(Coordinate.Zero);
var ua = transform.Transform(Texture.UAxis) - origin;
var va = transform.Transform(Texture.VAxis) - origin;
// Multiply the scales by the magnitudes (they were normals before the transform operation)
Texture.XScale *= ua.VectorMagnitude();
Texture.YScale *= va.VectorMagnitude();
}
{
// Transform the texture axes and move them back to the origin
var origin = transform.Transform(Coordinate.Zero);
var ua = transform.Transform(Texture.UAxis) - origin;
var va = transform.Transform(Texture.VAxis) - origin;
// Only do the transform if the axes end up being not perpendicular
// Otherwise just make a best-effort guess, same as the scaling lock
if (Math.Abs(ua.Dot(va)) < 0.0001m && DMath.Abs(Plane.Normal.Dot(ua.Cross(va).Normalise())) > 0.0001m)
{
Texture.UAxis = ua;
Texture.VAxis = va;
}
else
{
AlignTextureToFace();
}
if (flags.HasFlag(TransformFlags.TextureLock) && Texture.Texture != null)
{
// Check some original reference points to see how the transform mutates them
var scaled = (transform.Transform(Coordinate.One) - transform.Transform(Coordinate.Zero)).VectorMagnitude();
var original = (Coordinate.One - Coordinate.Zero).VectorMagnitude();
// Ignore texture lock when the transformation contains a scale
if (DMath.Abs(scaled - original) <= 0.01m)
{
// Calculate the new shift values based on the UV values of the vertices
var vtx = Vertices[0];
Texture.XShift = Texture.Texture.Width * vtx.TextureU - (vtx.Location.Dot(Texture.UAxis)) / Texture.XScale;
Texture.YShift = Texture.Texture.Height * vtx.TextureV - (vtx.Location.Dot(Texture.VAxis)) / Texture.YScale;
}
}
}
CalculateTextureCoordinates(true);
UpdateBoundingBox();
}
private bool DrawElasticConfiguration <T>(
string name,
bool expanded,
SerializedProperty elasticProperty,
SerializedProperty extentProperty,
TransformFlags requiredFlag,
TransformFlags providedFlags) where T : ElasticConfiguration
{
if (providedFlags.HasFlag(requiredFlag))
{
bool result = false;
using (new EditorGUI.IndentLevelScope())
{
result = InspectorUIUtility.DrawScriptableFoldout <T>(
elasticProperty,
name,
expanded);
EditorGUILayout.PropertyField(extentProperty, includeChildren: true);
}
return(result);
}
else
{
return(false);
}
}
public virtual void Transform(IUnitTransformation transform, TransformFlags flags)
{
foreach (var t in Vertices)
{
t.Location = transform.Transform(t.Location);
}
Plane = new Plane(Vertices[0].Location, Vertices[1].Location, Vertices[2].Location);
Colour = Colour;
if (flags.HasFlag(TransformFlags.TextureScalingLock) && Texture.Texture != null)
{
// Make a best-effort guess of retaining scaling. All bets are off during skew operations.
// Transform the current texture axes
var origin = transform.Transform(Coordinate.Zero);
var ua = transform.Transform(Texture.UAxis) - origin;
var va = transform.Transform(Texture.VAxis) - origin;
// Multiply the scales by the magnitudes (they were normals before the transform operation)
Texture.XScale *= ua.VectorMagnitude();
Texture.YScale *= va.VectorMagnitude();
}
{
// Transform the texture axes and move them back to the origin
var origin = transform.Transform(Coordinate.Zero);
var ua = transform.Transform(Texture.UAxis) - origin;
var va = transform.Transform(Texture.VAxis) - origin;
// Only do the transform if the axes end up being not perpendicular
// Otherwise just make a best-effort guess, same as the scaling lock
if (Math.Abs(ua.Dot(va)) < 0.0001m && DMath.Abs(Plane.Normal.Dot(ua.Cross(va).Normalise())) > 0.0001m)
{
Texture.UAxis = ua;
Texture.VAxis = va;
}
else
{
AlignTextureToFace();
}
if (flags.HasFlag(TransformFlags.TextureLock) && Texture.Texture != null)
{
// Check some original reference points to see how the transform mutates them
var scaled = (transform.Transform(Coordinate.One) - transform.Transform(Coordinate.Zero)).VectorMagnitude();
var original = (Coordinate.One - Coordinate.Zero).VectorMagnitude();
// Ignore texture lock when the transformation contains a scale
if (DMath.Abs(scaled - original) <= 0.01m)
{
// Calculate the new shift values based on the UV values of the vertices
var vtx = Vertices[0];
Texture.XShift = Texture.Texture.Width * vtx.TextureU - (vtx.Location.Dot(Texture.UAxis)) / Texture.XScale;
Texture.YShift = Texture.Texture.Height * vtx.TextureV - (vtx.Location.Dot(Texture.VAxis)) / Texture.YScale;
}
}
}
CalculateTextureCoordinates(true);
UpdateBoundingBox();
}
public bool IsDirected() => flags.HasFlag(TransformFlags.Directed);
public virtual void Transform(IUnitTransformation transform, TransformFlags flags)
{
foreach (var t in Vertices)
{
t.Location = transform.Transform(t.Location);
}
Plane = new Plane(Vertices[0].Location, Vertices[1].Location, Vertices[2].Location);
Colour = Colour;
if (flags.HasFlag(TransformFlags.TextureScalingLock) && Texture.Texture != null)
{
// Make a best-effort guess of retaining scaling. All bets are off during skew operations.
// Transform the current texture axes
var origin = transform.Transform(Coordinate.Zero);
var ua = transform.Transform(Texture.UAxis) - origin;
var va = transform.Transform(Texture.VAxis) - origin;
// Multiply the scales by the magnitudes (they were normals before the transform operation)
Texture.XScale *= ua.VectorMagnitude();
Texture.YScale *= va.VectorMagnitude();
}
if (flags.HasFlag(TransformFlags.TextureLock) && Texture.Texture != null)
{
// Transform the texture axes and move them back to the origin
var origin = transform.Transform(Coordinate.Zero);
var ua = transform.Transform(Texture.UAxis) - origin;
var va = transform.Transform(Texture.VAxis) - origin;
// Only do the transform if the axes end up being not perpendicular
// Otherwise just make a best-effort guess, same as the scaling lock
if (Math.Abs(ua.Dot(va)) < 0.0001m)
{
Texture.UAxis = ua;
Texture.VAxis = va;
}
// Calculate the new shift values based on the UV values of the vertices
var vtx = Vertices[0];
Texture.XShift = Texture.Texture.Width * vtx.TextureU - (vtx.Location.Dot(Texture.UAxis)) / Texture.XScale;
Texture.YShift = Texture.Texture.Height * vtx.TextureV - (vtx.Location.Dot(Texture.VAxis)) / Texture.YScale;
}
else
{
// During rotate/skew operations we'll mess up the texture axes, just reset them.
AlignTextureToFace();
}
CalculateTextureCoordinates();
UpdateBoundingBox();
}
public void OnReplayRecord(IReplayWriter stream, ReplayInfo info)
{
_transformFlags = TransformFlags.None;
if (info.ReplayStateMode == ReplayStateMode.Snapshot)
{
_snapshotPosition = transform.position;
_snapshotRotation = transform.rotation;
stream.Write(_snapshotPosition);
stream.Write(_snapshotRotation);
if (_rigidbody && trackRigid)
{
_snapshotVelocity = _rigidbody.velocity;
_snapshotAngularVelocity = _rigidbody.angularVelocity;
stream.Write(_snapshotVelocity);
stream.Write(_snapshotAngularVelocity);
}
}
else if (info.ReplayStateMode == ReplayStateMode.Delta)
{
if (!ReplayMath.IsApproximatelyEqual(transform.position, _snapshotPosition))
{
_transformFlags |= TransformFlags.Transform;
}
if (!ReplayMath.IsApproximatelyEqual(transform.rotation, _snapshotRotation))
{
_transformFlags |= TransformFlags.Rotation;
}
if (_rigidbody && trackRigid)
{
if (!ReplayMath.IsApproximatelyEqual(_rigidbody.velocity, _snapshotVelocity))
{
_transformFlags |= TransformFlags.Velocity;
}
if (!ReplayMath.IsApproximatelyEqual(_rigidbody.angularVelocity, _snapshotAngularVelocity))
{
_transformFlags |= TransformFlags.AngularVelocity;
}
}
stream.Write((byte)_transformFlags);
if (_transformFlags.HasFlag(TransformFlags.Transform))
{
if (info.ReplayDeltaMode == ReplayDeltaMode.DeltaCompression)
{
stream.Write(transform.position - _snapshotPosition);
_snapshotPosition = transform.position;
}
else if (info.ReplayDeltaMode == ReplayDeltaMode.SubFrame)
{
stream.Write(transform.position);
}
}
if (_transformFlags.HasFlag(TransformFlags.Rotation))
{
if (info.ReplayDeltaMode == ReplayDeltaMode.DeltaCompression)
{
stream.Write(transform.rotation * Quaternion.Inverse(_snapshotRotation));
_snapshotRotation = transform.rotation;
}
else if (info.ReplayDeltaMode == ReplayDeltaMode.SubFrame)
{
stream.Write(transform.rotation);
}
}
if (_transformFlags.HasFlag(TransformFlags.Velocity))
{
if (info.ReplayDeltaMode == ReplayDeltaMode.DeltaCompression)
{
stream.Write(_rigidbody.velocity - _snapshotVelocity);
_snapshotVelocity = _rigidbody.velocity;
}
else if (info.ReplayDeltaMode == ReplayDeltaMode.SubFrame)
{
stream.Write(_rigidbody.velocity);
}
}
if (_transformFlags.HasFlag(TransformFlags.AngularVelocity))
{
if (info.ReplayDeltaMode == ReplayDeltaMode.DeltaCompression)
{
stream.Write(_rigidbody.angularVelocity - _snapshotAngularVelocity);
_snapshotAngularVelocity = _rigidbody.angularVelocity;
}
else if (info.ReplayDeltaMode == ReplayDeltaMode.SubFrame)
{
stream.Write(_rigidbody.angularVelocity);
}
}
}
}
public virtual void Transform(IUnitTransformation transform, TransformFlags flags)
{
foreach (var t in Vertices)
{
t.Location = transform.Transform(t.Location);
}
Plane = new Plane(Vertices[0].Location, Vertices[1].Location, Vertices[2].Location);
Colour = Colour;
var origin = transform.Transform(Coordinate.Zero);
var ua = transform.Transform(Texture.UAxis) - origin;
var va = transform.Transform(Texture.VAxis) - origin;
if (flags.HasFlag(TransformFlags.TextureScalingLock) && Texture.Texture != null)
{
// Make a best-effort guess of retaining scaling. All bets are off during skew operations.
// Transform the current texture axes
// Multiply the scales by the magnitudes (they were normals before the transform operation)
Texture.XScale *= ua.VectorMagnitude();
Texture.YScale *= va.VectorMagnitude();
}
{
//NOTE(SVK):Only edit solids not entities. //do entities have faces??
if (this.Parent.Parent.GetType().Name == "World" && this.Parent.GetType().Name == "Solid")
{
if (Texture.Flags.HasFlag(FaceFlags.TextureLocked))
{
Coordinate Center = this.Parent.Parent.SelCenter;
Matrix Xfrm = transform.GetMatrix();
TransformFlags f = (TransformFlags)0;
if (Xfrm != Matrix.Zero)
{
f = GetTransformFlags(Xfrm);
}
else
{
f = flags;
}
if (f.HasFlag(TransformFlags.Translate))
{
Texture.PositionRF = transform.Transform(Texture.PositionRF);
}
if (f.HasFlag(TransformFlags.Rotation))
{
Xfrm = ToRF(Xfrm);
Texture.TransformAngleRF = Xfrm * Texture.TransformAngleRF;
Texture.PositionRF = Texture.PositionRF - Center;
Texture.PositionRF = RotateRF(Xfrm, ToRF(Texture.PositionRF));
Texture.PositionRF = ToChisel(Texture.PositionRF);
Texture.PositionRF = Texture.PositionRF + Center;
}
}
}
else //entities etc...
{
// Transform the texture axes and move them back to the origin
// Only do the transform if the axes end up being not perpendicular
// Otherwise just make a best-effort guess, same as the scaling lock
if (Math.Abs(ua.Dot(va)) < 0.0001m && DMath.Abs(Plane.Normal.Dot(ua.Cross(va).Normalise())) > 0.0001m)
{
Texture.UAxis = ua;
Texture.VAxis = va;
}
else
{
AlignTextureToWorld();
}
if (flags.HasFlag(TransformFlags.TextureLock) && Texture.Texture != null)
{
// Check some original reference points to see how the transform mutates them
var scaled = (transform.Transform(Coordinate.One) - transform.Transform(Coordinate.Zero)).VectorMagnitude();
var original = (Coordinate.One - Coordinate.Zero).VectorMagnitude();
// Ignore texture lock when the transformation contains a scale
if (DMath.Abs(scaled - original) <= 0.01m)
{
// Calculate the new shift values based on the UV values of the vertices
var vtx = Vertices[0];
Texture.XShift = Texture.Texture.Width * vtx.TextureU - (vtx.Location.Dot(Texture.UAxis)) / Texture.XScale;
Texture.YShift = Texture.Texture.Height * vtx.TextureV - (vtx.Location.Dot(Texture.VAxis)) / Texture.YScale;
}
}
}
}
AlignTexture();
UpdateBoundingBox();
}
