/// <summary>Scales the object by the specified factor.</summary>
/// <param name="factor">The factor by which to scale.</param>
/// <exception cref="System.ArgumentException">Raised when any component in the factor is zero.</exception>
public override void Scale(Vector3D factor) {
if (factor.X == 0.0 | factor.Y == 0.0 | factor.Z == 0.0) {
throw new ArgumentException("The factor contains components that are zero.");
}
for (int i = 0; i < this.SpatialCoordinates.Length; i++) {
this.SpatialCoordinates[i].Scale(factor);
}
double inverseFactorX = 1.0 / factor.X;
double inverseFactorY = 1.0 / factor.Y;
double inverseFactorZ = 1.0 / factor.Z;
double inverseFactorSquaredX = inverseFactorX * inverseFactorX;
double inverseFactorSquaredY = inverseFactorY * inverseFactorY;
double inverseFactorSquaredZ = inverseFactorZ * inverseFactorZ;
for (int i = 0; i < this.Normals.Length; i++) {
double normalSquaredX = this.Normals[i].X * this.Normals[i].X;
double normalSquaredY = this.Normals[i].Y * this.Normals[i].Y;
double normalSquaredZ = this.Normals[i].Z * this.Normals[i].Z;
double norm = normalSquaredX * inverseFactorSquaredX + normalSquaredY * inverseFactorSquaredY + normalSquaredZ * inverseFactorSquaredZ;
if (norm != 0.0) {
double scalar = System.Math.Sqrt((normalSquaredX + normalSquaredY + normalSquaredZ) / norm);
this.Normals[i].X *= inverseFactorX * scalar;
this.Normals[i].Y *= inverseFactorY * scalar;
this.Normals[i].Z *= inverseFactorZ * scalar;
}
}
if (factor.X * factor.Y * factor.Z < 0.0) {
for (int i = 0; i < this.Faces.Length; i++) {
this.Faces[i].Flip();
}
}
}
/// <summary>Rotates the object around the specified axis.</summary>
/// <param name="direction">The axis along which to rotate.</param>
/// <param name="cosineOfAngle">The cosine of the angle by which to rotate.</param>
/// <param name="sineOfAngle">The sine of the angle by which to rotate.</param>
public override void Rotate(Vector3D direction, double cosineOfAngle, double sineOfAngle) {
for (int i = 0; i < this.SpatialCoordinates.Length; i++) {
this.SpatialCoordinates[i].Rotate(direction, cosineOfAngle, sineOfAngle);
}
for (int i = 0; i < this.Normals.Length; i++) {
this.Normals[i].Rotate(direction, cosineOfAngle, sineOfAngle);
}
}
internal static void LoadDefaultPluginSounds(TrainManager.Train train, string trainFolder) {
Vector3D position = new Vector3D(train.Cars[train.DriverCar].DriverX, train.Cars[train.DriverCar].DriverY, train.Cars[train.DriverCar].DriverZ + 1.0);
const double radius = 2.0;
train.Cars[train.DriverCar].Sounds.Plugin = new TrainManager.CarSound[] {
TryLoadSound(OpenBveApi.Path.CombineFile(trainFolder, "ats.wav"), position, radius),
TryLoadSound(OpenBveApi.Path.CombineFile(trainFolder, "atscnt.wav"), position, radius),
TryLoadSound(OpenBveApi.Path.CombineFile(trainFolder, "ding.wav"), position, radius),
TryLoadSound(OpenBveApi.Path.CombineFile(trainFolder, "toats.wav"), position, radius),
TryLoadSound(OpenBveApi.Path.CombineFile(trainFolder, "toatc.wav"), position, radius),
TryLoadSound(OpenBveApi.Path.CombineFile(trainFolder, "eb.wav"), position, radius)
};
}
internal double Perform(TrainManager.Train Train, int CarIndex, Vector3D Position, double TrackPosition, int SectionIndex, bool IsPartOfTrain, double TimeElapsed) {
ExecuteFunctionScript(this, Train, CarIndex, Position, TrackPosition, SectionIndex, IsPartOfTrain, TimeElapsed);
return this.LastResult;
}
// --- constructors ---
/// <summary>Creates a new orientation in three-dimensional space.</summary>
/// <param name="x">The vector pointing right.</param>
/// <param name="y">The vector pointing up.</param>
/// <param name="z">The vector pointing forward.</param>
public Orientation3(Vector3D x, Vector3D y, Vector3D z) {
this.X = x;
this.Y = y;
this.Z = z;
}
// update absolute camera
internal static void UpdateAbsoluteCamera(double TimeElapsed) {
// zoom
double zm = World.CameraCurrentAlignment.Zoom;
AdjustAlignment(ref World.CameraCurrentAlignment.Zoom, World.CameraAlignmentDirection.Zoom, ref World.CameraAlignmentSpeed.Zoom, TimeElapsed, true);
if (zm != World.CameraCurrentAlignment.Zoom) {
ApplyZoom();
}
if (CameraMode == CameraViewMode.FlyBy | CameraMode == CameraViewMode.FlyByZooming) {
// fly-by
AdjustAlignment(ref World.CameraCurrentAlignment.Position.X, World.CameraAlignmentDirection.Position.X, ref World.CameraAlignmentSpeed.Position.X, TimeElapsed);
AdjustAlignment(ref World.CameraCurrentAlignment.Position.Y, World.CameraAlignmentDirection.Position.Y, ref World.CameraAlignmentSpeed.Position.Y, TimeElapsed);
double tr = World.CameraCurrentAlignment.TrackPosition;
AdjustAlignment(ref World.CameraCurrentAlignment.TrackPosition, World.CameraAlignmentDirection.TrackPosition, ref World.CameraAlignmentSpeed.TrackPosition, TimeElapsed);
if (tr != World.CameraCurrentAlignment.TrackPosition) {
TrackManager.UpdateTrackFollower(ref World.CameraTrackFollower, World.CameraCurrentAlignment.TrackPosition, true, false);
UpdateViewingDistances();
}
// camera
double px = World.CameraTrackFollower.WorldPosition.X;
double py = World.CameraTrackFollower.WorldPosition.Y;
double pz = World.CameraTrackFollower.WorldPosition.Z;
// position to focus on
double tx, ty, tz;
double zoomMultiplier;
{
const double heightFactor = 0.75;
TrainManager.Train bestTrain = null;
double bestDistanceSquared = double.MaxValue;
TrainManager.Train secondBestTrain = null;
double secondBestDistanceSquared = double.MaxValue;
foreach (TrainManager.Train train in TrainManager.Trains) {
if (train.State == TrainManager.TrainState.Available) {
double x = 0.5 * (train.Cars[0].FrontAxle.Follower.WorldPosition.X + train.Cars[0].RearAxle.Follower.WorldPosition.X);
double y = 0.5 * (train.Cars[0].FrontAxle.Follower.WorldPosition.Y + train.Cars[0].RearAxle.Follower.WorldPosition.Y) + heightFactor * train.Cars[0].Height;
double z = 0.5 * (train.Cars[0].FrontAxle.Follower.WorldPosition.Z + train.Cars[0].RearAxle.Follower.WorldPosition.Z);
double dx = x - px;
double dy = y - py;
double dz = z - pz;
double d = dx * dx + dy * dy + dz * dz;
if (d < bestDistanceSquared) {
secondBestTrain = bestTrain;
secondBestDistanceSquared = bestDistanceSquared;
bestTrain = train;
bestDistanceSquared = d;
} else if (d < secondBestDistanceSquared) {
secondBestTrain = train;
secondBestDistanceSquared = d;
}
}
}
if (bestTrain != null) {
const double maxDistance = 100.0;
double bestDistance = Math.Sqrt(bestDistanceSquared);
double secondBestDistance = Math.Sqrt(secondBestDistanceSquared);
if (secondBestTrain != null && secondBestDistance - bestDistance <= maxDistance) {
double x1 = 0.5 * (bestTrain.Cars[0].FrontAxle.Follower.WorldPosition.X + bestTrain.Cars[0].RearAxle.Follower.WorldPosition.X);
double y1 = 0.5 * (bestTrain.Cars[0].FrontAxle.Follower.WorldPosition.Y + bestTrain.Cars[0].RearAxle.Follower.WorldPosition.Y) + heightFactor * bestTrain.Cars[0].Height;
double z1 = 0.5 * (bestTrain.Cars[0].FrontAxle.Follower.WorldPosition.Z + bestTrain.Cars[0].RearAxle.Follower.WorldPosition.Z);
double d1;
{
double dx = x1 - px;
double dy = y1 - py;
double dz = z1 - pz;
d1 = dx * dx + dy * dy + dz * dz;
}
double x2 = 0.5 * (secondBestTrain.Cars[0].FrontAxle.Follower.WorldPosition.X + secondBestTrain.Cars[0].RearAxle.Follower.WorldPosition.X);
double y2 = 0.5 * (secondBestTrain.Cars[0].FrontAxle.Follower.WorldPosition.Y + secondBestTrain.Cars[0].RearAxle.Follower.WorldPosition.Y) + heightFactor * secondBestTrain.Cars[0].Height;
double z2 = 0.5 * (secondBestTrain.Cars[0].FrontAxle.Follower.WorldPosition.Z + secondBestTrain.Cars[0].RearAxle.Follower.WorldPosition.Z);
double d2;
{
double dx = x2 - px;
double dy = y2 - py;
double dz = z2 - pz;
d2 = dx * dx + dy * dy + dz * dz;
}
double t = 0.5 - (secondBestDistance - bestDistance) / (2.0 * maxDistance);
if (t < 0.0) t = 0.0;
t = 2.0 * t * t; /* in order to change the shape of the interpolation curve */
tx = (1.0 - t) * x1 + t * x2;
ty = (1.0 - t) * y1 + t * y2;
tz = (1.0 - t) * z1 + t * z2;
zoomMultiplier = 1.0 - 2.0 * t;
} else {
tx = 0.5 * (bestTrain.Cars[0].FrontAxle.Follower.WorldPosition.X + bestTrain.Cars[0].RearAxle.Follower.WorldPosition.X);
ty = 0.5 * (bestTrain.Cars[0].FrontAxle.Follower.WorldPosition.Y + bestTrain.Cars[0].RearAxle.Follower.WorldPosition.Y) + heightFactor * bestTrain.Cars[0].Height;
tz = 0.5 * (bestTrain.Cars[0].FrontAxle.Follower.WorldPosition.Z + bestTrain.Cars[0].RearAxle.Follower.WorldPosition.Z);
zoomMultiplier = 1.0;
}
} else {
tx = 0.0;
ty = 0.0;
tz = 0.0;
zoomMultiplier = 1.0;
}
}
// camera
{
double dx = World.CameraTrackFollower.WorldDirection.X;
double dy = World.CameraTrackFollower.WorldDirection.Y;
double dz = World.CameraTrackFollower.WorldDirection.Z;
double ux = World.CameraTrackFollower.WorldUp.X;
double uy = World.CameraTrackFollower.WorldUp.Y;
double uz = World.CameraTrackFollower.WorldUp.Z;
double sx = World.CameraTrackFollower.WorldSide.X;
double sy = World.CameraTrackFollower.WorldSide.Y;
double sz = World.CameraTrackFollower.WorldSide.Z;
double ox = World.CameraCurrentAlignment.Position.X;
double oy = World.CameraCurrentAlignment.Position.Y;
double oz = World.CameraCurrentAlignment.Position.Z;
double cx = px + sx * ox + ux * oy + dx * oz;
double cy = py + sy * ox + uy * oy + dy * oz;
double cz = pz + sz * ox + uz * oy + dz * oz;
AbsoluteCameraPosition = new Vector3D(cx, cy, cz);
dx = tx - cx;
dy = ty - cy;
dz = tz - cz;
double t = Math.Sqrt(dx * dx + dy * dy + dz * dz);
double ti = 1.0 / t;
dx *= ti;
dy *= ti;
dz *= ti;
AbsoluteCameraDirection = new Vector3D(dx, dy, dz);
AbsoluteCameraSide = new Vector3D(dz, 0.0, -dx);
Normalize(ref AbsoluteCameraSide.X, ref AbsoluteCameraSide.Y, ref AbsoluteCameraSide.Z);
World.Cross(dx, dy, dz, AbsoluteCameraSide.X, AbsoluteCameraSide.Y, AbsoluteCameraSide.Z, out AbsoluteCameraUp.X, out AbsoluteCameraUp.Y, out AbsoluteCameraUp.Z);
UpdateViewingDistances();
if (CameraMode == CameraViewMode.FlyByZooming) {
// zoom
const double fadeOutDistance = 600.0; /* the distance with the highest zoom factor is half the fade-out distance */
const double maxZoomFactor = 7.0; /* the zoom factor at half the fade-out distance */
const double factor = 256.0 / (fadeOutDistance * fadeOutDistance * fadeOutDistance * fadeOutDistance * fadeOutDistance * fadeOutDistance * fadeOutDistance * fadeOutDistance);
double zoom;
if (t < fadeOutDistance) {
double tdist4 = fadeOutDistance - t; tdist4 *= tdist4; tdist4 *= tdist4;
double t4 = t * t; t4 *= t4;
zoom = 1.0 + factor * zoomMultiplier * (maxZoomFactor - 1.0) * tdist4 * t4;
} else {
zoom = 1.0;
}
World.VerticalViewingAngle = World.OriginalVerticalViewingAngle / zoom;
MainLoop.UpdateViewport(MainLoop.ViewPortChangeMode.NoChange);
}
}
} else {
// non-fly-by
{
// current alignment
AdjustAlignment(ref World.CameraCurrentAlignment.Position.X, World.CameraAlignmentDirection.Position.X, ref World.CameraAlignmentSpeed.Position.X, TimeElapsed);
AdjustAlignment(ref World.CameraCurrentAlignment.Position.Y, World.CameraAlignmentDirection.Position.Y, ref World.CameraAlignmentSpeed.Position.Y, TimeElapsed);
AdjustAlignment(ref World.CameraCurrentAlignment.Position.Z, World.CameraAlignmentDirection.Position.Z, ref World.CameraAlignmentSpeed.Position.Z, TimeElapsed);
if ((CameraMode == CameraViewMode.Interior | World.CameraMode == World.CameraViewMode.InteriorLookAhead) & CameraRestriction == CameraRestrictionMode.On) {
if (CameraCurrentAlignment.Position.Z > 0.75) {
CameraCurrentAlignment.Position.Z = 0.75;
}
}
bool q = World.CameraAlignmentSpeed.Yaw != 0.0 | World.CameraAlignmentSpeed.Pitch != 0.0 | World.CameraAlignmentSpeed.Roll != 0.0;
AdjustAlignment(ref World.CameraCurrentAlignment.Yaw, World.CameraAlignmentDirection.Yaw, ref World.CameraAlignmentSpeed.Yaw, TimeElapsed);
AdjustAlignment(ref World.CameraCurrentAlignment.Pitch, World.CameraAlignmentDirection.Pitch, ref World.CameraAlignmentSpeed.Pitch, TimeElapsed);
AdjustAlignment(ref World.CameraCurrentAlignment.Roll, World.CameraAlignmentDirection.Roll, ref World.CameraAlignmentSpeed.Roll, TimeElapsed);
double tr = World.CameraCurrentAlignment.TrackPosition;
AdjustAlignment(ref World.CameraCurrentAlignment.TrackPosition, World.CameraAlignmentDirection.TrackPosition, ref World.CameraAlignmentSpeed.TrackPosition, TimeElapsed);
if (tr != World.CameraCurrentAlignment.TrackPosition) {
TrackManager.UpdateTrackFollower(ref World.CameraTrackFollower, World.CameraCurrentAlignment.TrackPosition, true, false);
q = true;
}
if (q) {
UpdateViewingDistances();
}
}
// camera
double cx = World.CameraTrackFollower.WorldPosition.X;
double cy = World.CameraTrackFollower.WorldPosition.Y;
double cz = World.CameraTrackFollower.WorldPosition.Z;
double dx = World.CameraTrackFollower.WorldDirection.X;
double dy = World.CameraTrackFollower.WorldDirection.Y;
double dz = World.CameraTrackFollower.WorldDirection.Z;
double ux = World.CameraTrackFollower.WorldUp.X;
double uy = World.CameraTrackFollower.WorldUp.Y;
double uz = World.CameraTrackFollower.WorldUp.Z;
double sx = World.CameraTrackFollower.WorldSide.X;
double sy = World.CameraTrackFollower.WorldSide.Y;
double sz = World.CameraTrackFollower.WorldSide.Z;
double lookaheadYaw;
double lookaheadPitch;
if (CameraMode == CameraViewMode.InteriorLookAhead) {
// look-ahead
double d = 20.0;
if (TrainManager.PlayerTrain.Specs.CurrentAverageSpeed > 0.0) {
d += 3.0 * (Math.Sqrt(TrainManager.PlayerTrain.Specs.CurrentAverageSpeed * TrainManager.PlayerTrain.Specs.CurrentAverageSpeed + 1.0) - 1.0);
}
d -= TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].FrontAxlePosition;
TrackManager.TrackFollower f = TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].FrontAxle.Follower;
f.TriggerType = TrackManager.EventTriggerType.None;
TrackManager.UpdateTrackFollower(ref f, f.TrackPosition + d, true, false);
double rx = f.WorldPosition.X - cx + World.CameraTrackFollower.WorldSide.X * TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverX + World.CameraTrackFollower.WorldUp.X * TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverY + World.CameraTrackFollower.WorldDirection.X * TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverZ;
double ry = f.WorldPosition.Y - cy + World.CameraTrackFollower.WorldSide.Y * TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverX + World.CameraTrackFollower.WorldUp.Y * TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverY + World.CameraTrackFollower.WorldDirection.Y * TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverZ;
double rz = f.WorldPosition.Z - cz + World.CameraTrackFollower.WorldSide.Z * TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverX + World.CameraTrackFollower.WorldUp.Z * TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverY + World.CameraTrackFollower.WorldDirection.Z * TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverZ;
World.Normalize(ref rx, ref ry, ref rz);
double t = dz * (sy * ux - sx * uy) + dy * (-sz * ux + sx * uz) + dx * (sz * uy - sy * uz);
if (t != 0.0) {
t = 1.0 / t;
double tx = (rz * (-dy * ux + dx * uy) + ry * (dz * ux - dx * uz) + rx * (-dz * uy + dy * uz)) * t;
double ty = (rz * (dy * sx - dx * sy) + ry * (-dz * sx + dx * sz) + rx * (dz * sy - dy * sz)) * t;
double tz = (rz * (sy * ux - sx * uy) + ry * (-sz * ux + sx * uz) + rx * (sz * uy - sy * uz)) * t;
lookaheadYaw = tx * tz != 0.0 ? Math.Atan2(tx, tz) : 0.0;
if (ty < -1.0) {
lookaheadPitch = -0.5 * Math.PI;
} else if (ty > 1.0) {
lookaheadPitch = 0.5 * Math.PI;
} else {
lookaheadPitch = Math.Asin(ty);
}
} else {
lookaheadYaw = 0.0;
lookaheadPitch = 0.0;
}
} else {
lookaheadYaw = 0.0;
lookaheadPitch = 0.0;
}
{
// cab pitch and yaw
double tx = World.CameraCurrentAlignment.Position.X;
double ty = World.CameraCurrentAlignment.Position.Y;
double tz = World.CameraCurrentAlignment.Position.Z;
double dx2 = dx, dy2 = dy, dz2 = dz;
double ux2 = ux, uy2 = uy, uz2 = uz;
if ((World.CameraMode == CameraViewMode.Interior | World.CameraMode == World.CameraViewMode.InteriorLookAhead) & TrainManager.PlayerTrain != null) {
int c = TrainManager.PlayerTrain.DriverCar;
if (c >= 0) {
if (TrainManager.PlayerTrain.Cars[c].CarSections.Length == 0 || !TrainManager.PlayerTrain.Cars[c].CarSections[0].Overlay) {
double a = TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverPitch;
double cosa = Math.Cos(-a);
double sina = Math.Sin(-a);
World.Rotate(ref dx2, ref dy2, ref dz2, sx, sy, sz, cosa, sina);
World.Rotate(ref ux2, ref uy2, ref uz2, sx, sy, sz, cosa, sina);
}
}
}
cx += sx * tx + ux2 * ty + dx2 * tz;
cy += sy * tx + uy2 * ty + dy2 * tz;
cz += sz * tx + uz2 * ty + dz2 * tz;
}
// yaw, pitch, roll
double headYaw = World.CameraCurrentAlignment.Yaw + lookaheadYaw;
if ((World.CameraMode == CameraViewMode.Interior | World.CameraMode == World.CameraViewMode.InteriorLookAhead) & TrainManager.PlayerTrain != null) {
if (TrainManager.PlayerTrain.DriverCar >= 0) {
headYaw += TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverYaw;
}
}
double headPitch = World.CameraCurrentAlignment.Pitch + lookaheadPitch;
if ((World.CameraMode == CameraViewMode.Interior | World.CameraMode == World.CameraViewMode.InteriorLookAhead) & TrainManager.PlayerTrain != null) {
if (TrainManager.PlayerTrain.DriverCar >= 0) {
headPitch += TrainManager.PlayerTrain.Cars[TrainManager.PlayerTrain.DriverCar].DriverPitch;
}
}
double bodyPitch = 0.0;
double bodyRoll = 0.0;
double headRoll = World.CameraCurrentAlignment.Roll;
// rotation
if (CameraRestriction == CameraRestrictionMode.NotAvailable & (CameraMode == CameraViewMode.Interior | CameraMode == CameraViewMode.InteriorLookAhead)) {
// with body and head
bodyPitch += CurrentDriverBody.Pitch;
headPitch -= 0.2 * CurrentDriverBody.Pitch;
bodyRoll += CurrentDriverBody.Roll;
headRoll += 0.2 * CurrentDriverBody.Roll;
const double bodyHeight = 0.6;
const double headHeight = 0.1;
{
// body pitch
double ry = (Math.Cos(-bodyPitch) - 1.0) * bodyHeight;
double rz = Math.Sin(-bodyPitch) * bodyHeight;
cx += dx * rz + ux * ry;
cy += dy * rz + uy * ry;
cz += dz * rz + uz * ry;
if (bodyPitch != 0.0) {
double cosa = Math.Cos(-bodyPitch);
double sina = Math.Sin(-bodyPitch);
World.Rotate(ref dx, ref dy, ref dz, sx, sy, sz, cosa, sina);
World.Rotate(ref ux, ref uy, ref uz, sx, sy, sz, cosa, sina);
}
}
{
// body roll
double rx = Math.Sin(bodyRoll) * bodyHeight;
double ry = (Math.Cos(bodyRoll) - 1.0) * bodyHeight;
cx += sx * rx + ux * ry;
cy += sy * rx + uy * ry;
cz += sz * rx + uz * ry;
if (bodyRoll != 0.0) {
double cosa = Math.Cos(-bodyRoll);
double sina = Math.Sin(-bodyRoll);
World.Rotate(ref ux, ref uy, ref uz, dx, dy, dz, cosa, sina);
World.Rotate(ref sx, ref sy, ref sz, dx, dy, dz, cosa, sina);
}
}
{
// head yaw
double rx = Math.Sin(headYaw) * headHeight;
double rz = (Math.Cos(headYaw) - 1.0) * headHeight;
cx += sx * rx + dx * rz;
cy += sy * rx + dy * rz;
cz += sz * rx + dz * rz;
if (headYaw != 0.0) {
double cosa = Math.Cos(headYaw);
double sina = Math.Sin(headYaw);
World.Rotate(ref dx, ref dy, ref dz, ux, uy, uz, cosa, sina);
World.Rotate(ref sx, ref sy, ref sz, ux, uy, uz, cosa, sina);
}
}
{
// head pitch
double ry = (Math.Cos(-headPitch) - 1.0) * headHeight;
double rz = Math.Sin(-headPitch) * headHeight;
cx += dx * rz + ux * ry;
cy += dy * rz + uy * ry;
cz += dz * rz + uz * ry;
if (headPitch != 0.0) {
double cosa = Math.Cos(-headPitch);
double sina = Math.Sin(-headPitch);
World.Rotate(ref dx, ref dy, ref dz, sx, sy, sz, cosa, sina);
World.Rotate(ref ux, ref uy, ref uz, sx, sy, sz, cosa, sina);
}
}
{
// head roll
double rx = Math.Sin(headRoll) * headHeight;
double ry = (Math.Cos(headRoll) - 1.0) * headHeight;
cx += sx * rx + ux * ry;
cy += sy * rx + uy * ry;
cz += sz * rx + uz * ry;
if (headRoll != 0.0) {
double cosa = Math.Cos(-headRoll);
double sina = Math.Sin(-headRoll);
World.Rotate(ref ux, ref uy, ref uz, dx, dy, dz, cosa, sina);
World.Rotate(ref sx, ref sy, ref sz, dx, dy, dz, cosa, sina);
}
}
} else {
// without body or head
double totalYaw = headYaw;
double totalPitch = headPitch + bodyPitch;
double totalRoll = bodyRoll + headRoll;
if (totalYaw != 0.0) {
double cosa = Math.Cos(totalYaw);
double sina = Math.Sin(totalYaw);
World.Rotate(ref dx, ref dy, ref dz, ux, uy, uz, cosa, sina);
World.Rotate(ref sx, ref sy, ref sz, ux, uy, uz, cosa, sina);
}
if (totalPitch != 0.0) {
double cosa = Math.Cos(-totalPitch);
double sina = Math.Sin(-totalPitch);
World.Rotate(ref dx, ref dy, ref dz, sx, sy, sz, cosa, sina);
World.Rotate(ref ux, ref uy, ref uz, sx, sy, sz, cosa, sina);
}
if (totalRoll != 0.0) {
double cosa = Math.Cos(-totalRoll);
double sina = Math.Sin(-totalRoll);
World.Rotate(ref ux, ref uy, ref uz, dx, dy, dz, cosa, sina);
World.Rotate(ref sx, ref sy, ref sz, dx, dy, dz, cosa, sina);
}
}
// finish
AbsoluteCameraPosition = new Vector3D(cx, cy, cz);
AbsoluteCameraDirection = new Vector3D(dx, dy, dz);
AbsoluteCameraUp = new Vector3D(ux, uy, uz);
AbsoluteCameraSide = new Vector3D(sx, sy, sz);
}
}
internal CameraAlignment(Vector3D Position, double Yaw, double Pitch, double Roll, double TrackPosition, double Zoom) {
this.Position = Position;
this.Yaw = Yaw;
this.Pitch = Pitch;
this.Roll = Roll;
this.TrackPosition = TrackPosition;
this.Zoom = Zoom;
}
internal Vertex(double X, double Y, double Z) {
this.Coordinates = new Vector3D(X, Y, Z);
this.TextureCoordinates = new Vector2f(0.0f, 0.0f);
}
internal static void RotatePlane(ref Vector3D Vector, double cosa, double sina) {
double u = Vector.X * cosa - Vector.Z * sina;
double v = Vector.X * sina + Vector.Z * cosa;
Vector.X = u;
Vector.Z = v;
}
private CarSound(Sounds.SoundBuffer buffer, Sounds.SoundSource source, Vector3D position) {
this.Buffer = buffer;
this.Source = source;
this.Position = position;
}
// update car section element
private static void UpdateCarSectionElement(Train Train, int CarIndex, int SectionIndex, int ElementIndex, Vector3D Position, Vector3D Direction, Vector3D Up, Vector3D Side, bool Show, double TimeElapsed, bool ForceUpdate) {
Vector3D p;
if (Train.Cars[CarIndex].CarSections[SectionIndex].Overlay & World.CameraRestriction != World.CameraRestrictionMode.NotAvailable) {
p = new Vector3D(Train.Cars[CarIndex].DriverX, Train.Cars[CarIndex].DriverY, Train.Cars[CarIndex].DriverZ);
} else {
p = Position;
}
double timeDelta;
bool updatefunctions;
if (Train.Cars[CarIndex].CarSections[SectionIndex].Elements[ElementIndex].RefreshRate != 0.0) {
if (Train.Cars[CarIndex].CarSections[SectionIndex].Elements[ElementIndex].SecondsSinceLastUpdate >= Train.Cars[CarIndex].CarSections[SectionIndex].Elements[ElementIndex].RefreshRate) {
timeDelta = Train.Cars[CarIndex].CarSections[SectionIndex].Elements[ElementIndex].SecondsSinceLastUpdate;
Train.Cars[CarIndex].CarSections[SectionIndex].Elements[ElementIndex].SecondsSinceLastUpdate = TimeElapsed;
updatefunctions = true;
} else {
timeDelta = TimeElapsed;
Train.Cars[CarIndex].CarSections[SectionIndex].Elements[ElementIndex].SecondsSinceLastUpdate += TimeElapsed;
updatefunctions = false;
}
} else {
timeDelta = Train.Cars[CarIndex].CarSections[SectionIndex].Elements[ElementIndex].SecondsSinceLastUpdate;
Train.Cars[CarIndex].CarSections[SectionIndex].Elements[ElementIndex].SecondsSinceLastUpdate = TimeElapsed;
updatefunctions = true;
}
updatefunctions |= ForceUpdate;
ObjectManager.UpdateAnimatedObject(ref Train.Cars[CarIndex].CarSections[SectionIndex].Elements[ElementIndex], true, Train, CarIndex, Train.Cars[CarIndex].CurrentCarSection, Train.Cars[CarIndex].FrontAxle.Follower.TrackPosition - Train.Cars[CarIndex].FrontAxlePosition, p, Direction, Up, Side, Train.Cars[CarIndex].CarSections[SectionIndex].Overlay, updatefunctions, Show, timeDelta);
}
// load bve 2 sound
private static void LoadBve2Sound(string TrainPath, TrainManager.Train train) {
// set sound positions and radii
Vector3D front = new Vector3D(0.0, 0.0, 0.5 * train.Cars[train.DriverCar].Length);
Vector3D center = new Vector3D(0.0, 0.0, 0.0);
Vector3D left = new Vector3D(-1.3, 0.0, 0.0);
Vector3D right = new Vector3D(1.3, 0.0, 0.0);
Vector3D cab = new Vector3D(-train.Cars[train.DriverCar].DriverX, train.Cars[train.DriverCar].DriverY, train.Cars[train.DriverCar].DriverZ - 0.5);
Vector3D panel = new Vector3D(train.Cars[train.DriverCar].DriverX, train.Cars[train.DriverCar].DriverY, train.Cars[train.DriverCar].DriverZ + 1.0);
const double large = 30.0;
const double medium = 10.0;
const double small = 5.0;
const double tiny = 2.0;
LoadNoSound(train);
// load sounds for driver's car
train.Cars[train.DriverCar].Sounds.Adjust = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Adjust.wav"), panel, tiny);
train.Cars[train.DriverCar].Sounds.Brake = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Brake.wav"), center, small);
train.Cars[train.DriverCar].Sounds.Halt = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Halt.wav"), cab, tiny);
train.Cars[train.DriverCar].Sounds.Horns[0].Sound = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Klaxon0.wav"), front, large);
train.Cars[train.DriverCar].Sounds.Horns[0].Loop = false;
if (train.Cars[train.DriverCar].Sounds.Horns[0].Sound.Buffer == null) {
train.Cars[train.DriverCar].Sounds.Horns[0].Sound = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Klaxon.wav"), front, large);
}
train.Cars[train.DriverCar].Sounds.Horns[1].Sound = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Klaxon1.wav"), front, large);
train.Cars[train.DriverCar].Sounds.Horns[1].Loop = false;
train.Cars[train.DriverCar].Sounds.Horns[2].Sound = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Klaxon2.wav"), front, medium);
train.Cars[train.DriverCar].Sounds.Horns[2].Loop = true;
train.Cars[train.DriverCar].Sounds.PilotLampOn = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Leave.wav"), cab, tiny);
train.Cars[train.DriverCar].Sounds.PilotLampOff = TrainManager.CarSound.Empty;
// load sounds for all cars
for (int i = 0; i < train.Cars.Length; i++) {
Vector3D frontaxle = new Vector3D(0.0, 0.0, train.Cars[i].FrontAxlePosition);
Vector3D rearaxle = new Vector3D(0.0, 0.0, train.Cars[i].RearAxlePosition);
train.Cars[i].Sounds.Air = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Air.wav"), center, small);
train.Cars[i].Sounds.AirHigh = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "AirHigh.wav"), center, small);
train.Cars[i].Sounds.AirZero = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "AirZero.wav"), center, small);
if (train.Cars[i].Specs.AirBrake.Type == TrainManager.AirBrakeType.Main) {
train.Cars[i].Sounds.CpEnd = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "CpEnd.wav"), center, medium);
train.Cars[i].Sounds.CpLoop = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "CpLoop.wav"), center, medium);
train.Cars[i].Sounds.CpStart = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "CpStart.wav"), center, medium);
}
train.Cars[i].Sounds.BreakerResume = TrainManager.CarSound.Empty;
train.Cars[i].Sounds.BreakerResumeOrInterrupt = TrainManager.CarSound.Empty;
train.Cars[i].Sounds.BreakerResumed = false;
train.Cars[i].Sounds.DoorCloseL = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "DoorClsL.wav"), left, small);
train.Cars[i].Sounds.DoorCloseR = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "DoorClsR.wav"), right, small);
if (train.Cars[i].Sounds.DoorCloseL.Buffer == null) {
train.Cars[i].Sounds.DoorCloseL = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "DoorCls.wav"), left, small);
}
if (train.Cars[i].Sounds.DoorCloseR.Buffer == null) {
train.Cars[i].Sounds.DoorCloseR = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "DoorCls.wav"), right, small);
}
train.Cars[i].Sounds.DoorOpenL = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "DoorOpnL.wav"), left, small);
train.Cars[i].Sounds.DoorOpenR = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "DoorOpnR.wav"), right, small);
if (train.Cars[i].Sounds.DoorOpenL.Buffer == null) {
train.Cars[i].Sounds.DoorOpenL = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "DoorOpn.wav"), left, small);
}
if (train.Cars[i].Sounds.DoorOpenR.Buffer == null) {
train.Cars[i].Sounds.DoorOpenR = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "DoorOpn.wav"), right, small);
}
train.Cars[i].Sounds.EmrBrake = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "EmrBrake.wav"), center, medium);
train.Cars[i].Sounds.Flange = TryLoadSoundArray(TrainPath, "Flange", ".wav", center, medium);
train.Cars[i].Sounds.FlangeVolume = new double[train.Cars[i].Sounds.Flange.Length];
train.Cars[i].Sounds.Loop = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Loop.wav"), center, medium);
train.Cars[i].Sounds.PointFrontAxle = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Point.wav"), frontaxle, small);
train.Cars[i].Sounds.PointRearAxle = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Point.wav"), rearaxle, small);
train.Cars[i].Sounds.Rub = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Rub.wav"), center, medium);
train.Cars[i].Sounds.Run = TryLoadSoundArray(TrainPath, "Run", ".wav", center, medium);
train.Cars[i].Sounds.RunVolume = new double[train.Cars[i].Sounds.Run.Length];
train.Cars[i].Sounds.SpringL = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "SpringL.wav"), left, small);
train.Cars[i].Sounds.SpringR = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "SpringR.wav"), right, small);
// motor sound
if (train.Cars[i].Specs.IsMotorCar) {
System.Globalization.CultureInfo Culture = System.Globalization.CultureInfo.InvariantCulture;
train.Cars[i].Sounds.Motor.Position = center;
for (int j = 0; j < train.Cars[i].Sounds.Motor.Tables.Length; j++) {
for (int k = 0; k < train.Cars[i].Sounds.Motor.Tables[j].Entries.Length; k++) {
int idx = train.Cars[i].Sounds.Motor.Tables[j].Entries[k].SoundIndex;
if (idx >= 0) {
TrainManager.CarSound snd = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, "Motor" + idx.ToString(Culture) + ".wav"), center, medium);
train.Cars[i].Sounds.Motor.Tables[j].Entries[k].Buffer = snd.Buffer;
}
}
}
}
}
}
private static TrainManager.CarSound[] TryLoadSoundArray(string Folder, string FileStart, string FileEnd, Vector3D Position, double Radius) {
System.Globalization.CultureInfo Culture = System.Globalization.CultureInfo.InvariantCulture;
TrainManager.CarSound[] Sounds = new TrainManager.CarSound[] { };
string[] Files = System.IO.Directory.GetFiles(Folder);
for (int i = 0; i < Files.Length; i++) {
string a = System.IO.Path.GetFileName(Files[i]);
if (a.Length > FileStart.Length + FileEnd.Length) {
if (a.StartsWith(FileStart, StringComparison.OrdinalIgnoreCase) & a.EndsWith(FileEnd, StringComparison.OrdinalIgnoreCase)) {
string b = a.Substring(FileStart.Length, a.Length - FileEnd.Length - FileStart.Length);
int n; if (int.TryParse(b, System.Globalization.NumberStyles.Integer, Culture, out n)) {
if (n >= 0) {
int m = Sounds.Length;
if (n >= m) {
Array.Resize<TrainManager.CarSound>(ref Sounds, n + 1);
for (int j = m; j < n; j++) {
Sounds[j] = TrainManager.CarSound.Empty;
Sounds[j].Source = null;
}
}
Sounds[n] = TryLoadSound(Files[i], Position, Radius);
}
}
}
}
}
return Sounds;
}
// try load sound
private static TrainManager.CarSound TryLoadSound(string FileName, Vector3D Position, double Radius) {
TrainManager.CarSound s;
s = TrainManager.CarSound.Empty;
s.Position = Position;
s.Source = null;
if (FileName != null) {
if (System.IO.File.Exists(FileName)) {
s.Buffer = Sounds.RegisterBuffer(FileName, Radius);
}
}
return s;
}
// load bve 4 sound
private static void LoadBve4Sound(string FileName, string TrainPath, System.Text.Encoding Encoding, TrainManager.Train train) {
// set sound positions and radii
Vector3D center = new Vector3D(0.0, 0.0, 0.0);
Vector3D left = new Vector3D(-1.3, 0.0, 0.0);
Vector3D right = new Vector3D(1.3, 0.0, 0.0);
Vector3D front = new Vector3D(0.0, 0.0, 0.5 * train.Cars[train.DriverCar].Length);
Vector3D cab = new Vector3D(-train.Cars[train.DriverCar].DriverX, train.Cars[train.DriverCar].DriverY, train.Cars[train.DriverCar].DriverZ - 0.5);
Vector3D panel = new Vector3D(train.Cars[train.DriverCar].DriverX, train.Cars[train.DriverCar].DriverY, train.Cars[train.DriverCar].DriverZ + 1.0);
const double large = 30.0;
const double medium = 10.0;
const double small = 5.0;
const double tiny = 2.0;
LoadNoSound(train);
// parse configuration file
System.Globalization.CultureInfo Culture = System.Globalization.CultureInfo.InvariantCulture;
string[] Lines = System.IO.File.ReadAllLines(FileName, Encoding);
for (int i = 0; i < Lines.Length; i++) {
int j = Lines[i].IndexOf(';');
if (j >= 0) {
Lines[i] = Lines[i].Substring(0, j).Trim();
} else {
Lines[i] = Lines[i].Trim();
}
}
if (Lines.Length < 1 || string.Compare(Lines[0], "version 1.0", StringComparison.OrdinalIgnoreCase) != 0) {
Debug.AddMessage(Debug.MessageType.Error, false, "Invalid file format encountered in " + FileName + ". The first line is expected to be \"Version 1.0\".");
}
string[] MotorFiles = new string[] { };
double invfac = Lines.Length == 0 ? Loading.TrainProgressCurrentWeight : Loading.TrainProgressCurrentWeight / (double)Lines.Length;
for (int i = 0; i < Lines.Length; i++) {
Loading.TrainProgress = Loading.TrainProgressCurrentSum + invfac * (double)i;
if ((i & 7) == 0) {
System.Threading.Thread.Sleep(1);
if (Loading.Cancel) return;
}
switch (Lines[i].ToLowerInvariant()) {
case "[run]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
int k;
if (!int.TryParse(a, System.Globalization.NumberStyles.Integer, Culture, out k)) {
Debug.AddMessage(Debug.MessageType.Error, false, "Invalid index appeared at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
if (k >= 0) {
for (int c = 0; c < train.Cars.Length; c++) {
int n = train.Cars[c].Sounds.Run.Length;
if (k >= n) {
Array.Resize<TrainManager.CarSound>(ref train.Cars[c].Sounds.Run, k + 1);
for (int h = n; h < k; h++) {
train.Cars[c].Sounds.Run[h] = TrainManager.CarSound.Empty;
}
}
train.Cars[c].Sounds.Run[k] = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, medium);
}
} else {
Debug.AddMessage(Debug.MessageType.Error, false, "Index must be greater or equal to zero at line " + (i + 1).ToString(Culture) + " in file " + FileName);
}
}
} i++;
} i--; break;
case "[flange]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
int k;
if (!int.TryParse(a, System.Globalization.NumberStyles.Integer, Culture, out k)) {
Debug.AddMessage(Debug.MessageType.Error, false, "Invalid index appeared at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
if (k >= 0) {
for (int c = 0; c < train.Cars.Length; c++) {
int n = train.Cars[c].Sounds.Flange.Length;
if (k >= n) {
Array.Resize<TrainManager.CarSound>(ref train.Cars[c].Sounds.Flange, k + 1);
for (int h = n; h < k; h++) {
train.Cars[c].Sounds.Flange[h] = TrainManager.CarSound.Empty;
}
}
train.Cars[c].Sounds.Flange[k] = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, medium);
}
} else {
Debug.AddMessage(Debug.MessageType.Error, false, "Index must be greater or equal to zero at line " + (i + 1).ToString(Culture) + " in file " + FileName);
}
}
} i++;
} i--; break;
case "[motor]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
int k;
if (!int.TryParse(a, System.Globalization.NumberStyles.Integer, Culture, out k)) {
Debug.AddMessage(Debug.MessageType.Error, false, "Invalid index appeared at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
if (k >= 0) {
if (k >= MotorFiles.Length) {
Array.Resize<string>(ref MotorFiles, k + 1);
}
MotorFiles[k] = OpenBveApi.Path.CombineFile(TrainPath, b);
if (!System.IO.File.Exists(MotorFiles[k])) {
Debug.AddMessage(Debug.MessageType.Error, true, "File " + MotorFiles[k] + " does not exist at line " + (i + 1).ToString(Culture) + " in file " + FileName);
MotorFiles[k] = null;
}
} else {
Debug.AddMessage(Debug.MessageType.Error, false, "Index is invalid at line " + (i + 1).ToString(Culture) + " in file " + FileName);
}
}
} i++;
} i--; break;
case "[switch]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else if (a == "0") {
for (int c = 0; c < train.Cars.Length; c++) {
Vector3D frontaxle = new Vector3D(0.0, 0.0, train.Cars[c].FrontAxlePosition);
Vector3D rearaxle = new Vector3D(0.0, 0.0, train.Cars[c].RearAxlePosition);
train.Cars[c].Sounds.PointFrontAxle = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), frontaxle, small);
train.Cars[c].Sounds.PointRearAxle = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), rearaxle, small);
}
} else {
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported index " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
}
} i++;
} i--; break;
case "[brake]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
switch (a.ToLowerInvariant()) {
case "bc release high":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.AirHigh = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, small);
} break;
case "bc release":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.Air = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, small);
} break;
case "bc release full":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.AirZero = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, small);
} break;
case "emergency":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.EmrBrake = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, medium);
} break;
case "bp decomp":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.Brake = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, small);
} break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
} i++;
} i--; break;
case "[compressor]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
for (int c = 0; c < train.Cars.Length; c++) {
if (train.Cars[c].Specs.AirBrake.Type == TrainManager.AirBrakeType.Main) {
switch (a.ToLowerInvariant()) {
case "attack":
train.Cars[c].Sounds.CpStart = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, medium);
break;
case "loop":
train.Cars[c].Sounds.CpLoop = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, medium);
break;
case "release":
train.Cars[c].Sounds.CpEnd = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, medium);
break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
}
}
} i++;
} i--; break;
case "[suspension]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
switch (a.ToLowerInvariant()) {
case "left":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.SpringL = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), left, small);
} break;
case "right":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.SpringR = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), right, small);
} break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
} i++;
} i--; break;
case "[horn]":
i++;
while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
switch (a.ToLowerInvariant()) {
case "primary":
train.Cars[train.DriverCar].Sounds.Horns[0].Sound = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), front, large);
train.Cars[train.DriverCar].Sounds.Horns[0].Loop = false;
break;
case "secondary":
train.Cars[train.DriverCar].Sounds.Horns[1].Sound = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), front, large);
train.Cars[train.DriverCar].Sounds.Horns[1].Loop = false;
break;
case "music":
train.Cars[train.DriverCar].Sounds.Horns[2].Sound = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), front, medium);
train.Cars[train.DriverCar].Sounds.Horns[2].Loop = true;
break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
} i++;
} i--; break;
case "[door]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
switch (a.ToLowerInvariant()) {
case "open left":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.DoorOpenL = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), left, small);
} break;
case "open right":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.DoorOpenR = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), left, small);
} break;
case "close left":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.DoorCloseL = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), left, small);
} break;
case "close right":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.DoorCloseR = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), left, small);
} break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
} i++;
} i--; break;
case "[ats]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
int k;
if (!int.TryParse(a, System.Globalization.NumberStyles.Integer, Culture, out k)) {
Debug.AddMessage(Debug.MessageType.Error, false, "Invalid index appeared at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
if (k >= 0) {
int n = train.Cars[train.DriverCar].Sounds.Plugin.Length;
if (k >= n) {
Array.Resize<TrainManager.CarSound>(ref train.Cars[train.DriverCar].Sounds.Plugin, k + 1);
for (int h = n; h < k; h++) {
train.Cars[train.DriverCar].Sounds.Plugin[h] = TrainManager.CarSound.Empty;
}
}
train.Cars[train.DriverCar].Sounds.Plugin[k] = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
} else {
Debug.AddMessage(Debug.MessageType.Warning, false, "Index must be greater or equal to zero at line " + (i + 1).ToString(Culture) + " in file " + FileName);
}
}
}
} i++;
} i--; break;
case "[buzzer]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
switch (a.ToLowerInvariant()) {
case "correct":
train.Cars[train.DriverCar].Sounds.Adjust = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
} i++;
} i--; break;
case "[pilot lamp]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
switch (a.ToLowerInvariant()) {
case "on":
train.Cars[train.DriverCar].Sounds.PilotLampOn = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
case "off":
train.Cars[train.DriverCar].Sounds.PilotLampOff = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
} i++;
} i--; break;
case "[brake handle]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
switch (a.ToLowerInvariant()) {
case "apply":
train.Cars[train.DriverCar].Sounds.BrakeHandleApply = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
case "release":
train.Cars[train.DriverCar].Sounds.BrakeHandleRelease = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
case "min":
train.Cars[train.DriverCar].Sounds.BrakeHandleMin = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
case "max":
train.Cars[train.DriverCar].Sounds.BrakeHandleMax = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
} i++;
} i--; break;
case "[master controller]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
switch (a.ToLowerInvariant()) {
case "up":
train.Cars[train.DriverCar].Sounds.MasterControllerUp = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
case "down":
train.Cars[train.DriverCar].Sounds.MasterControllerDown = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
case "min":
train.Cars[train.DriverCar].Sounds.MasterControllerMin = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
case "max":
train.Cars[train.DriverCar].Sounds.MasterControllerMax = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
} i++;
} i--; break;
case "[reverser]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
switch (a.ToLowerInvariant()) {
case "on":
train.Cars[train.DriverCar].Sounds.ReverserOn = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
case "off":
train.Cars[train.DriverCar].Sounds.ReverserOff = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, tiny);
break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
} i++;
} i--; break;
case "[breaker]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
switch (a.ToLowerInvariant()) {
case "on":
train.Cars[train.DriverCar].Sounds.BreakerResume = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, small);
break;
case "off":
train.Cars[train.DriverCar].Sounds.BreakerResumeOrInterrupt = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), panel, small);
break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
} i++;
} i--; break;
case "[others]":
i++; while (i < Lines.Length && !Lines[i].StartsWith("[", StringComparison.Ordinal)) {
int j = Lines[i].IndexOf("=", StringComparison.Ordinal);
if (j >= 0) {
string a = Lines[i].Substring(0, j).TrimEnd();
string b = Lines[i].Substring(j + 1).TrimStart();
if (b.Length == 0 || OpenBveApi.Path.ContainsInvalidPathChars(b)) {
Debug.AddMessage(Debug.MessageType.Error, false, "FileName contains illegal characters or is empty at line " + (i + 1).ToString(Culture) + " in file " + FileName);
} else {
switch (a.ToLowerInvariant()) {
case "noise":
for (int c = 0; c < train.Cars.Length; c++) {
if (train.Cars[c].Specs.IsMotorCar | c == train.DriverCar) {
train.Cars[c].Sounds.Loop = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, medium);
}
} break;
case "shoe":
for (int c = 0; c < train.Cars.Length; c++) {
train.Cars[c].Sounds.Rub = TryLoadSound(OpenBveApi.Path.CombineFile(TrainPath, b), center, medium);
} break;
default:
Debug.AddMessage(Debug.MessageType.Warning, false, "Unsupported key " + a + " encountered at line " + (i + 1).ToString(Culture) + " in file " + FileName);
break;
}
}
} i++;
} i--; break;
}
}
for (int i = 0; i < train.Cars.Length; i++) {
train.Cars[i].Sounds.RunVolume = new double[train.Cars[i].Sounds.Run.Length];
train.Cars[i].Sounds.FlangeVolume = new double[train.Cars[i].Sounds.Flange.Length];
}
// motor sound
for (int c = 0; c < train.Cars.Length; c++) {
if (train.Cars[c].Specs.IsMotorCar) {
train.Cars[c].Sounds.Motor.Position = center;
for (int i = 0; i < train.Cars[c].Sounds.Motor.Tables.Length; i++) {
train.Cars[c].Sounds.Motor.Tables[i].Buffer = null;
train.Cars[c].Sounds.Motor.Tables[i].Source = null;
for (int j = 0; j < train.Cars[c].Sounds.Motor.Tables[i].Entries.Length; j++) {
int index = train.Cars[c].Sounds.Motor.Tables[i].Entries[j].SoundIndex;
if (index >= 0 && index < MotorFiles.Length && MotorFiles[index] != null) {
train.Cars[c].Sounds.Motor.Tables[i].Entries[j].Buffer = Sounds.RegisterBuffer(MotorFiles[index], medium);
}
}
}
}
}
}
internal Transformation(Transformation Transformation, double Yaw, double Pitch, double Roll) {
double sx = Transformation.X.X, sy = Transformation.X.Y, sz = Transformation.X.Z;
double ux = Transformation.Y.X, uy = Transformation.Y.Y, uz = Transformation.Y.Z;
double dx = Transformation.Z.X, dy = Transformation.Z.Y, dz = Transformation.Z.Z;
double cosYaw = Math.Cos(Yaw);
double sinYaw = Math.Sin(Yaw);
double cosPitch = Math.Cos(-Pitch);
double sinPitch = Math.Sin(-Pitch);
double cosRoll = Math.Cos(Roll);
double sinRoll = Math.Sin(Roll);
Rotate(ref sx, ref sy, ref sz, ux, uy, uz, cosYaw, sinYaw);
Rotate(ref dx, ref dy, ref dz, ux, uy, uz, cosYaw, sinYaw);
Rotate(ref ux, ref uy, ref uz, sx, sy, sz, cosPitch, sinPitch);
Rotate(ref dx, ref dy, ref dz, sx, sy, sz, cosPitch, sinPitch);
Rotate(ref sx, ref sy, ref sz, dx, dy, dz, cosRoll, sinRoll);
Rotate(ref ux, ref uy, ref uz, dx, dy, dz, cosRoll, sinRoll);
this.X = new Vector3D(sx, sy, sz);
this.Y = new Vector3D(ux, uy, uz);
this.Z = new Vector3D(dx, dy, dz);
}
internal Transformation(Transformation BaseTransformation, Transformation AuxTransformation) {
Vector3D x = BaseTransformation.X;
Vector3D y = BaseTransformation.Y;
Vector3D z = BaseTransformation.Z;
Vector3D s = AuxTransformation.X;
Vector3D u = AuxTransformation.Y;
Vector3D d = AuxTransformation.Z;
Rotate(ref x.X, ref x.Y, ref x.Z, d.X, d.Y, d.Z, u.X, u.Y, u.Z, s.X, s.Y, s.Z);
Rotate(ref y.X, ref y.Y, ref y.Z, d.X, d.Y, d.Z, u.X, u.Y, u.Z, s.X, s.Y, s.Z);
Rotate(ref z.X, ref z.Y, ref z.Z, d.X, d.Y, d.Z, u.X, u.Y, u.Z, s.X, s.Y, s.Z);
this.X = x;
this.Y = y;
this.Z = z;
}
internal ObjectGroup() {
this.List = new ObjectList();
this.OpenGlDisplayList = 0;
this.OpenGlDisplayListAvailable = false;
this.WorldPosition = new Vector3D(0.0, 0.0, 0.0);
this.Update = true;
}
internal static void RotateUpDown(ref Vector3D Vector, double dx, double dy, double cosa, double sina) {
double x = Vector.X, y = Vector.Y, z = Vector.Z;
double u = dy * x - dx * z;
double v = dx * x + dy * z;
Vector.X = dy * u + dx * v * cosa - dx * y * sina;
Vector.Y = y * cosa + v * sina;
Vector.Z = -dx * u + dy * v * cosa - dy * y * sina;
}
/// <summary>Translates the object by the specified offset.</summary> /// <param name="offset">The offset by which to translate.</param> public abstract void Translate(Vector3D offset);
internal Vertex(Vector3D Coordinates, Vector2f TextureCoordinates) {
this.Coordinates = Coordinates;
this.TextureCoordinates = TextureCoordinates;
}
/// <summary>Translates the object by the specified offset that is measured in the specified orientation.</summary> /// <param name="orientation">The orientation along which to translate.</param> /// <param name="offset">The offset measured in the specified orientation.</param> public abstract void Translate(Orientation3 orientation, Vector3D offset);
internal static bool PerformCameraRestrictionTest() {
if (World.CameraRestriction != CameraRestrictionMode.On)
return true;
Vector3D[] p = new Vector3D[] { CameraRestrictionBottomLeft, CameraRestrictionTopRight };
Vector2D[] r = new Vector2D[2];
for (int j = 0; j < 2; j++) {
// determine relative world coordinates
World.Rotate(ref p[j].X, ref p[j].Y, ref p[j].Z, World.AbsoluteCameraDirection.X, World.AbsoluteCameraDirection.Y, World.AbsoluteCameraDirection.Z, World.AbsoluteCameraUp.X, World.AbsoluteCameraUp.Y, World.AbsoluteCameraUp.Z, World.AbsoluteCameraSide.X, World.AbsoluteCameraSide.Y, World.AbsoluteCameraSide.Z);
double rx = -Math.Tan(World.CameraCurrentAlignment.Yaw) - World.CameraCurrentAlignment.Position.X;
double ry = -Math.Tan(World.CameraCurrentAlignment.Pitch) - World.CameraCurrentAlignment.Position.Y;
double rz = -World.CameraCurrentAlignment.Position.Z;
p[j].X += rx * World.AbsoluteCameraSide.X + ry * World.AbsoluteCameraUp.X + rz * World.AbsoluteCameraDirection.X;
p[j].Y += rx * World.AbsoluteCameraSide.Y + ry * World.AbsoluteCameraUp.Y + rz * World.AbsoluteCameraDirection.Y;
p[j].Z += rx * World.AbsoluteCameraSide.Z + ry * World.AbsoluteCameraUp.Z + rz * World.AbsoluteCameraDirection.Z;
// determine screen coordinates
double ez = AbsoluteCameraDirection.X * p[j].X + AbsoluteCameraDirection.Y * p[j].Y + AbsoluteCameraDirection.Z * p[j].Z;
if (ez == 0.0)
return false;
double ex = AbsoluteCameraSide.X * p[j].X + AbsoluteCameraSide.Y * p[j].Y + AbsoluteCameraSide.Z * p[j].Z;
double ey = AbsoluteCameraUp.X * p[j].X + AbsoluteCameraUp.Y * p[j].Y + AbsoluteCameraUp.Z * p[j].Z;
r[j].X = ex / (ez * Math.Tan(0.5 * HorizontalViewingAngle));
r[j].Y = ey / (ez * Math.Tan(0.5 * VerticalViewingAngle));
}
return r[0].X <= -1.0025 & r[1].X >= 1.0025 & r[0].Y <= -1.0025 & r[1].Y >= 1.0025;
}
/// <summary>Rotates the object around the specified axis.</summary> /// <param name="direction">The axis along which to rotate.</param> /// <param name="cosineOfAngle">The cosine of the angle by which to rotate.</param> /// <param name="sineOfAngle">The sine of the angle by which to rotate.</param> public abstract void Rotate(Vector3D direction, double cosineOfAngle, double sineOfAngle);
internal Transformation(double Yaw, double Pitch, double Roll) {
if (Yaw == 0.0 & Pitch == 0.0 & Roll == 0.0) {
this.X = new Vector3D(1.0, 0.0, 0.0);
this.Y = new Vector3D(0.0, 1.0, 0.0);
this.Z = new Vector3D(0.0, 0.0, 1.0);
} else if (Pitch == 0.0 & Roll == 0.0) {
double cosYaw = Math.Cos(Yaw);
double sinYaw = Math.Sin(Yaw);
this.X = new Vector3D(cosYaw, 0.0, -sinYaw);
this.Y = new Vector3D(0.0, 1.0, 0.0);
this.Z = new Vector3D(sinYaw, 0.0, cosYaw);
} else {
double sx = 1.0, sy = 0.0, sz = 0.0;
double ux = 0.0, uy = 1.0, uz = 0.0;
double dx = 0.0, dy = 0.0, dz = 1.0;
double cosYaw = Math.Cos(Yaw);
double sinYaw = Math.Sin(Yaw);
double cosPitch = Math.Cos(-Pitch);
double sinPitch = Math.Sin(-Pitch);
double cosRoll = Math.Cos(-Roll);
double sinRoll = Math.Sin(-Roll);
Rotate(ref sx, ref sy, ref sz, ux, uy, uz, cosYaw, sinYaw);
Rotate(ref dx, ref dy, ref dz, ux, uy, uz, cosYaw, sinYaw);
Rotate(ref ux, ref uy, ref uz, sx, sy, sz, cosPitch, sinPitch);
Rotate(ref dx, ref dy, ref dz, sx, sy, sz, cosPitch, sinPitch);
Rotate(ref sx, ref sy, ref sz, dx, dy, dz, cosRoll, sinRoll);
Rotate(ref ux, ref uy, ref uz, dx, dy, dz, cosRoll, sinRoll);
this.X = new Vector3D(sx, sy, sz);
this.Y = new Vector3D(ux, uy, uz);
this.Z = new Vector3D(dx, dy, dz);
}
}
/// <summary>Scales the object by the specified factor.</summary> /// <param name="factor">The factor by which to scale.</param> public abstract void Scale(Vector3D factor);
// create element
private static int CreateElement(TrainManager.Train Train, double Left, double Top, double Width, double Height, double RelativeRotationCenterX, double RelativeRotationCenterY, double Distance, double PanelResolution, double PanelLeft, double PanelRight, double PanelTop, double PanelBottom, double PanelBitmapWidth, double PanelBitmapHeight, double PanelCenterX, double PanelCenterY, double PanelOriginX, double PanelOriginY, double DriverX, double DriverY, double DriverZ, Textures.Texture DaytimeTexture, Textures.Texture NighttimeTexture, Color32 Color, bool AddStateToLastElement) {
double WorldWidth, WorldHeight;
if (Screen.Width >= Screen.Height) {
WorldWidth = 2.0 * Math.Tan(0.5 * World.HorizontalViewingAngle) * EyeDistance;
WorldHeight = WorldWidth / World.AspectRatio;
} else {
WorldHeight = 2.0 * Math.Tan(0.5 * World.VerticalViewingAngle) * EyeDistance / World.AspectRatio;
WorldWidth = WorldHeight * World.AspectRatio;
}
double x0 = Left / PanelResolution;
double x1 = (Left + Width) / PanelResolution;
double y0 = (PanelBottom - Top) / PanelResolution * World.AspectRatio;
double y1 = (PanelBottom - (Top + Height)) / PanelResolution * World.AspectRatio;
double xd = 0.5 - PanelCenterX / PanelResolution;
x0 += xd; x1 += xd;
double yt = PanelBottom - PanelResolution / World.AspectRatio;
double yd = (PanelCenterY - yt) / (PanelBottom - yt) - 0.5;
y0 += yd; y1 += yd;
x0 = (x0 - 0.5) * WorldWidth;
x1 = (x1 - 0.5) * WorldWidth;
y0 = (y0 - 0.5) * WorldHeight;
y1 = (y1 - 0.5) * WorldHeight;
double xm = x0 * (1.0 - RelativeRotationCenterX) + x1 * RelativeRotationCenterX;
double ym = y0 * (1.0 - RelativeRotationCenterY) + y1 * RelativeRotationCenterY;
Vector3D[] v = new Vector3D[4];
v[0] = new Vector3D(x0 - xm, y1 - ym, 0);
v[1] = new Vector3D(x0 - xm, y0 - ym, 0);
v[2] = new Vector3D(x1 - xm, y0 - ym, 0);
v[3] = new Vector3D(x1 - xm, y1 - ym, 0);
World.Vertex t0 = new World.Vertex(v[0], new Vector2f(0.0f, 1.0f));
World.Vertex t1 = new World.Vertex(v[1], new Vector2f(0.0f, 0.0f));
World.Vertex t2 = new World.Vertex(v[2], new Vector2f(1.0f, 0.0f));
World.Vertex t3 = new World.Vertex(v[3], new Vector2f(1.0f, 1.0f));
ObjectManager.StaticObject Object = new ObjectManager.StaticObject();
Object.Mesh.Vertices = new World.Vertex[] { t0, t1, t2, t3 };
Object.Mesh.Faces = new World.MeshFace[] { new World.MeshFace(new int[] { 0, 1, 2, 3 }) };
Object.Mesh.Materials = new World.MeshMaterial[1];
Object.Mesh.Materials[0].Flags = (byte)(DaytimeTexture != null ? World.MeshMaterial.TransparentColorMask : 0);
Object.Mesh.Materials[0].Color = Color;
Object.Mesh.Materials[0].TransparentColor = new Color24(0, 0, 255);
Object.Mesh.Materials[0].DaytimeTexture = DaytimeTexture;
Object.Mesh.Materials[0].NighttimeTexture = NighttimeTexture;
Object.Dynamic = true;
// calculate offset
Vector3D o;
o.X = xm + DriverX;
o.Y = ym + DriverY;
o.Z = EyeDistance - Distance + DriverZ;
// add object
if (AddStateToLastElement) {
int n = Train.Cars[Train.DriverCar].CarSections[0].Elements.Length - 1;
int j = Train.Cars[Train.DriverCar].CarSections[0].Elements[n].States.Length;
Array.Resize<ObjectManager.AnimatedObjectState>(ref Train.Cars[Train.DriverCar].CarSections[0].Elements[n].States, j + 1);
Train.Cars[Train.DriverCar].CarSections[0].Elements[n].States[j].Position = o;
Train.Cars[Train.DriverCar].CarSections[0].Elements[n].States[j].Object = Object;
return n;
} else {
int n = Train.Cars[Train.DriverCar].CarSections[0].Elements.Length;
Array.Resize<ObjectManager.AnimatedObject>(ref Train.Cars[Train.DriverCar].CarSections[0].Elements, n + 1);
Train.Cars[Train.DriverCar].CarSections[0].Elements[n] = new ObjectManager.AnimatedObject();
Train.Cars[Train.DriverCar].CarSections[0].Elements[n].States = new ObjectManager.AnimatedObjectState[1];
Train.Cars[Train.DriverCar].CarSections[0].Elements[n].States[0].Position = o;
Train.Cars[Train.DriverCar].CarSections[0].Elements[n].States[0].Object = Object;
Train.Cars[Train.DriverCar].CarSections[0].Elements[n].CurrentState = 0;
Train.Cars[Train.DriverCar].CarSections[0].Elements[n].ObjectIndex = ObjectManager.CreateDynamicObject();
ObjectManager.Objects[Train.Cars[Train.DriverCar].CarSections[0].Elements[n].ObjectIndex] = ObjectManager.CloneObject(Object);
return n;
}
}
/// <summary>Gets the intensity of the glow.</summary> /// <param name="cameraPosition">The position of the camera.</param> /// <param name="cameraOrientation">The orientation of the camera.</param> /// <param name="objectPosition">The position of the object.</param> /// <param name="objectOrientation">The orientation of the object.</param> /// <returns>The intensity of the glow expressed as a value between 0 and 1.</returns> public abstract double GetIntensity(Vector3D cameraPosition, Orientation3 cameraOrientation, Vector3D objectPosition, Vector3D objectOrientation);
// execute function script
private static void ExecuteFunctionScript(FunctionScript Function, TrainManager.Train Train, int CarIndex, Vector3D Position, double TrackPosition, int SectionIndex, bool IsPartOfTrain, double TimeElapsed) {
int s = 0, c = 0;
for (int i = 0; i < Function.Instructions.Length; i++) {
switch (Function.Instructions[i]) {
// system
case Instructions.SystemHalt:
i = Function.Instructions.Length;
break;
case Instructions.SystemConstant:
Function.Stack[s] = Function.Constants[c];
s++; c++; break;
case Instructions.SystemConstantArray:
{
int n = (int)Function.Instructions[i + 1];
for (int j = 0; j < n; j++) {
Function.Stack[s + j] = Function.Constants[c + j];
} s += n; c += n; i++;
} break;
case Instructions.SystemValue:
Function.Stack[s] = Function.LastResult;
s++; break;
case Instructions.SystemDelta:
Function.Stack[s] = TimeElapsed;
s++; break;
// stack
case Instructions.StackCopy:
Function.Stack[s] = Function.Stack[s - 1];
s++; break;
case Instructions.StackSwap:
{
double a = Function.Stack[s - 1];
Function.Stack[s - 1] = Function.Stack[s - 2];
Function.Stack[s - 2] = a;
} break;
// math
case Instructions.MathPlus:
Function.Stack[s - 2] += Function.Stack[s - 1];
s--; break;
case Instructions.MathSubtract:
Function.Stack[s - 2] -= Function.Stack[s - 1];
s--; break;
case Instructions.MathMinus:
Function.Stack[s - 1] = -Function.Stack[s - 1];
break;
case Instructions.MathTimes:
Function.Stack[s - 2] *= Function.Stack[s - 1];
s--; break;
case Instructions.MathDivide:
Function.Stack[s - 2] = Function.Stack[s - 1] == 0.0 ? 0.0 : Function.Stack[s - 2] / Function.Stack[s - 1];
s--; break;
case Instructions.MathReciprocal:
Function.Stack[s - 1] = Function.Stack[s - 1] == 0.0 ? 0.0 : 1.0 / Function.Stack[s - 1];
break;
case Instructions.MathPower:
{
double a = Function.Stack[s - 2];
double b = Function.Stack[s - 1];
if (b == 2.0) {
Function.Stack[s - 2] = a * a;
} else if (b == 3.0) {
Function.Stack[s - 2] = a * a * a;
} else if (b == 4.0) {
double t = a * a;
Function.Stack[s - 2] = t * t;
} else if (b == 5.0) {
double t = a * a;
Function.Stack[s - 2] = t * t * a;
} else if (b == 6.0) {
double t = a * a * a;
Function.Stack[s - 2] = t * t;
} else if (b == 7.0) {
double t = a * a * a;
Function.Stack[s - 2] = t * t * a;
} else if (b == 8.0) {
double t = a * a; t *= t;
Function.Stack[s - 2] = t * t;
} else if (b == 0.0) {
Function.Stack[s - 2] = 1.0;
} else if (b < 0.0) {
Function.Stack[s - 2] = 0.0;
} else {
Function.Stack[s - 2] = Math.Pow(a, b);
}
s--; break;
}
case Instructions.MathIncrement:
Function.Stack[s - 1] += 1.0;
break;
case Instructions.MathDecrement:
Function.Stack[s - 1] -= 1.0;
break;
case Instructions.MathFusedMultiplyAdd:
Function.Stack[s - 3] = Function.Stack[s - 3] * Function.Stack[s - 2] + Function.Stack[s - 1];
s -= 2; break;
case Instructions.MathQuotient:
Function.Stack[s - 2] = Function.Stack[s - 1] == 0.0 ? 0.0 : Math.Floor(Function.Stack[s - 2] / Function.Stack[s - 1]);
s--; break;
case Instructions.MathMod:
Function.Stack[s - 2] = Function.Stack[s - 1] == 0.0 ? 0.0 : Function.Stack[s - 2] - Function.Stack[s - 1] * Math.Floor(Function.Stack[s - 2] / Function.Stack[s - 1]);
s--; break;
case Instructions.MathFloor:
Function.Stack[s - 1] = Math.Floor(Function.Stack[s - 1]);
break;
case Instructions.MathCeiling:
Function.Stack[s - 1] = Math.Ceiling(Function.Stack[s - 1]);
break;
case Instructions.MathRound:
Function.Stack[s - 1] = Math.Round(Function.Stack[s - 1]);
break;
case Instructions.MathMin:
Function.Stack[s - 2] = Function.Stack[s - 2] < Function.Stack[s - 1] ? Function.Stack[s - 2] : Function.Stack[s - 1];
s--; break;
case Instructions.MathMax:
Function.Stack[s - 2] = Function.Stack[s - 2] > Function.Stack[s - 1] ? Function.Stack[s - 2] : Function.Stack[s - 1];
s--; break;
case Instructions.MathAbs:
Function.Stack[s - 1] = Math.Abs(Function.Stack[s - 1]);
break;
case Instructions.MathSign:
Function.Stack[s - 1] = Math.Sign(Function.Stack[s - 1]);
break;
case Instructions.MathExp:
Function.Stack[s - 1] = Math.Exp(Function.Stack[s - 1]);
break;
case Instructions.MathLog:
Function.Stack[s - 1] = Log(Function.Stack[s - 1]);
break;
case Instructions.MathSqrt:
Function.Stack[s - 1] = Sqrt(Function.Stack[s - 1]);
break;
case Instructions.MathSin:
Function.Stack[s - 1] = Math.Sin(Function.Stack[s - 1]);
break;
case Instructions.MathCos:
Function.Stack[s - 1] = Math.Cos(Function.Stack[s - 1]);
break;
case Instructions.MathTan:
Function.Stack[s - 1] = Tan(Function.Stack[s - 1]);
break;
case Instructions.MathArcTan:
Function.Stack[s - 1] = Math.Atan(Function.Stack[s - 1]);
break;
// comparisons
case Instructions.CompareEqual:
Function.Stack[s - 2] = Function.Stack[s - 2] == Function.Stack[s - 1] ? 1.0 : 0.0;
s--; break;
case Instructions.CompareUnequal:
Function.Stack[s - 2] = Function.Stack[s - 2] != Function.Stack[s - 1] ? 1.0 : 0.0;
s--; break;
case Instructions.CompareLess:
Function.Stack[s - 2] = Function.Stack[s - 2] < Function.Stack[s - 1] ? 1.0 : 0.0;
s--; break;
case Instructions.CompareGreater:
Function.Stack[s - 2] = Function.Stack[s - 2] > Function.Stack[s - 1] ? 1.0 : 0.0;
s--; break;
case Instructions.CompareLessEqual:
Function.Stack[s - 2] = Function.Stack[s - 2] <= Function.Stack[s - 1] ? 1.0 : 0.0;
s--; break;
case Instructions.CompareGreaterEqual:
Function.Stack[s - 2] = Function.Stack[s - 2] >= Function.Stack[s - 1] ? 1.0 : 0.0;
s--; break;
case Instructions.CompareConditional:
Function.Stack[s - 3] = Function.Stack[s - 3] != 0.0 ? Function.Stack[s - 2] : Function.Stack[s - 1];
s -= 2; break;
// logical
case Instructions.LogicalNot:
Function.Stack[s - 1] = Function.Stack[s - 1] != 0.0 ? 0.0 : 1.0;
break;
case Instructions.LogicalAnd:
Function.Stack[s - 2] = Function.Stack[s - 2] != 0.0 & Function.Stack[s - 1] != 0.0 ? 1.0 : 0.0;
s--; break;
case Instructions.LogicalOr:
Function.Stack[s - 2] = Function.Stack[s - 2] != 0.0 | Function.Stack[s - 1] != 0.0 ? 1.0 : 0.0;
s--; break;
case Instructions.LogicalNand:
Function.Stack[s - 2] = Function.Stack[s - 2] != 0.0 & Function.Stack[s - 1] != 0.0 ? 0.0 : 1.0;
s--; break;
case Instructions.LogicalNor:
Function.Stack[s - 2] = Function.Stack[s - 2] != 0.0 | Function.Stack[s - 1] != 0.0 ? 0.0 : 1.0;
s--; break;
case Instructions.LogicalXor:
Function.Stack[s - 2] = Function.Stack[s - 2] != 0.0 ^ Function.Stack[s - 1] != 0.0 ? 1.0 : 0.0;
s--; break;
// time/camera
case Instructions.TimeSecondsSinceMidnight:
Function.Stack[s] = Game.SecondsSinceMidnight;
s++; break;
case Instructions.CameraDistance:
{
double dx = World.AbsoluteCameraPosition.X - Position.X;
double dy = World.AbsoluteCameraPosition.Y - Position.Y;
double dz = World.AbsoluteCameraPosition.Z - Position.Z;
Function.Stack[s] = Math.Sqrt(dx * dx + dy * dy + dz * dz);
s++;
} break;
// train
case Instructions.TrainCars:
if (Train != null) {
Function.Stack[s] = (double)Train.Cars.Length;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.TrainSpeed:
if (Train != null) {
Function.Stack[s] = Train.Cars[CarIndex].Specs.CurrentSpeed;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.TrainSpeedOfCar:
if (Train != null) {
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
Function.Stack[s - 1] = Train.Cars[j].Specs.CurrentSpeed;
} else {
Function.Stack[s - 1] = 0.0;
}
} else {
Function.Stack[s - 1] = 0.0;
}
break;
case Instructions.TrainSpeedometer:
if (Train != null) {
Function.Stack[s] = Train.Cars[CarIndex].Specs.CurrentPerceivedSpeed;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.TrainSpeedometerOfCar:
if (Train != null) {
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
Function.Stack[s - 1] = Train.Cars[j].Specs.CurrentPerceivedSpeed;
} else {
Function.Stack[s - 1] = 0.0;
}
} else {
Function.Stack[s - 1] = 0.0;
}
break;
case Instructions.TrainAcceleration:
if (Train != null) {
Function.Stack[s] = Train.Cars[CarIndex].Specs.CurrentAcceleration;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.TrainAccelerationOfCar:
if (Train != null) {
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
Function.Stack[s - 1] = Train.Cars[j].Specs.CurrentAcceleration;
} else {
Function.Stack[s - 1] = 0.0;
}
} else {
Function.Stack[s - 1] = 0.0;
}
break;
case Instructions.TrainAccelerationMotor:
if (Train != null) {
Function.Stack[s] = 0.0;
for (int j = 0; j < Train.Cars.Length; j++) {
if (Train.Cars[j].Specs.IsMotorCar) {
// hack: CurrentAccelerationOutput does not distinguish between forward/backward
if (Train.Cars[j].Specs.CurrentAccelerationOutput < 0.0) {
Function.Stack[s] = Train.Cars[j].Specs.CurrentAccelerationOutput * (double)Math.Sign(Train.Cars[j].Specs.CurrentSpeed);
} else if (Train.Cars[j].Specs.CurrentAccelerationOutput > 0.0) {
Function.Stack[s] = Train.Cars[j].Specs.CurrentAccelerationOutput * (double)Train.Specs.CurrentReverser.Actual;
} else {
Function.Stack[s] = 0.0;
}
break;
}
}
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.TrainAccelerationMotorOfCar:
if (Train != null) {
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
// hack: CurrentAccelerationOutput does not distinguish between forward/backward
if (Train.Cars[j].Specs.CurrentAccelerationOutput < 0.0) {
Function.Stack[s - 1] = Train.Cars[j].Specs.CurrentAccelerationOutput * (double)Math.Sign(Train.Cars[j].Specs.CurrentSpeed);
} else if (Train.Cars[j].Specs.CurrentAccelerationOutput > 0.0) {
Function.Stack[s - 1] = Train.Cars[j].Specs.CurrentAccelerationOutput * (double)Train.Specs.CurrentReverser.Actual;
} else {
Function.Stack[s - 1] = 0.0;
}
} else {
Function.Stack[s - 1] = 0.0;
}
} else {
Function.Stack[s - 1] = 0.0;
}
break;
case Instructions.TrainDistance:
if (Train != null) {
double dist = double.MaxValue;
for (int j = 0; j < Train.Cars.Length; j++) {
double fx = Train.Cars[j].FrontAxle.Follower.WorldPosition.X - Position.X;
double fy = Train.Cars[j].FrontAxle.Follower.WorldPosition.Y - Position.Y;
double fz = Train.Cars[j].FrontAxle.Follower.WorldPosition.Z - Position.Z;
double f = fx * fx + fy * fy + fz * fz;
if (f < dist) dist = f;
double rx = Train.Cars[j].RearAxle.Follower.WorldPosition.X - Position.X;
double ry = Train.Cars[j].RearAxle.Follower.WorldPosition.Y - Position.Y;
double rz = Train.Cars[j].RearAxle.Follower.WorldPosition.Z - Position.Z;
double r = rx * rx + ry * ry + rz * rz;
if (r < dist) dist = r;
}
Function.Stack[s] = Math.Sqrt(dist);
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.TrainDistanceToCar:
if (Train != null) {
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
double x = 0.5 * (Train.Cars[j].FrontAxle.Follower.WorldPosition.X + Train.Cars[j].RearAxle.Follower.WorldPosition.X) - Position.X;
double y = 0.5 * (Train.Cars[j].FrontAxle.Follower.WorldPosition.Y + Train.Cars[j].RearAxle.Follower.WorldPosition.Y) - Position.Y;
double z = 0.5 * (Train.Cars[j].FrontAxle.Follower.WorldPosition.Z + Train.Cars[j].RearAxle.Follower.WorldPosition.Z) - Position.Z;
Function.Stack[s - 1] = Math.Sqrt(x * x + y * y + z * z);
} else {
Function.Stack[s - 1] = 0.0;
}
} else {
Function.Stack[s - 1] = 0.0;
}
break;
case Instructions.TrainTrackDistance:
if (Train != null) {
int r = Train.Cars.Length - 1;
double t0 = Train.Cars[0].FrontAxle.Follower.TrackPosition - Train.Cars[0].FrontAxlePosition + 0.5 * Train.Cars[0].Length;
double t1 = Train.Cars[r].RearAxle.Follower.TrackPosition - Train.Cars[r].RearAxlePosition - 0.5 * Train.Cars[r].Length;
Function.Stack[s] = TrackPosition > t0 ? TrackPosition - t0 : TrackPosition < t1 ? TrackPosition - t1 : 0.0;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.TrainTrackDistanceToCar:
if (Train != null) {
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
double p = 0.5 * (Train.Cars[j].FrontAxle.Follower.TrackPosition + Train.Cars[j].RearAxle.Follower.TrackPosition);
Function.Stack[s - 1] = TrackPosition - p;
} else {
Function.Stack[s - 1] = 0.0;
}
} else {
Function.Stack[s - 1] = 0.0;
}
break;
// door
case Instructions.Doors:
if (Train != null) {
double a = 0.0;
for (int j = 0; j < Train.Cars.Length; j++) {
for (int k = 0; k < Train.Cars[j].Specs.Doors.Length; k++) {
if (Train.Cars[j].Specs.Doors[k].State > a) {
a = Train.Cars[j].Specs.Doors[k].State;
}
}
}
Function.Stack[s] = a;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.DoorsIndex:
if (Train != null) {
double a = 0.0;
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
for (int k = 0; k < Train.Cars[j].Specs.Doors.Length; k++) {
if (Train.Cars[j].Specs.Doors[k].State > a) {
a = Train.Cars[j].Specs.Doors[k].State;
}
}
}
Function.Stack[s - 1] = a;
} else {
Function.Stack[s - 1] = 0.0;
}
break;
case Instructions.LeftDoors:
if (Train != null) {
double a = 0.0;
for (int j = 0; j < Train.Cars.Length; j++) {
for (int k = 0; k < Train.Cars[j].Specs.Doors.Length; k++) {
if (Train.Cars[j].Specs.Doors[k].Direction == -1 & Train.Cars[j].Specs.Doors[k].State > a) {
a = Train.Cars[j].Specs.Doors[k].State;
}
}
}
Function.Stack[s] = a;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.LeftDoorsIndex:
if (Train != null) {
double a = 0.0;
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
for (int k = 0; k < Train.Cars[j].Specs.Doors.Length; k++) {
if (Train.Cars[j].Specs.Doors[k].Direction == -1 & Train.Cars[j].Specs.Doors[k].State > a) {
a = Train.Cars[j].Specs.Doors[k].State;
}
}
}
Function.Stack[s - 1] = a;
} else {
Function.Stack[s - 1] = 0.0;
}
break;
case Instructions.RightDoors:
if (Train != null) {
double a = 0.0;
for (int j = 0; j < Train.Cars.Length; j++) {
for (int k = 0; k < Train.Cars[j].Specs.Doors.Length; k++) {
if (Train.Cars[j].Specs.Doors[k].Direction == 1 & Train.Cars[j].Specs.Doors[k].State > a) {
a = Train.Cars[j].Specs.Doors[k].State;
}
}
}
Function.Stack[s] = a;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.RightDoorsIndex:
if (Train != null) {
double a = 0.0;
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
for (int k = 0; k < Train.Cars[j].Specs.Doors.Length; k++) {
if (Train.Cars[j].Specs.Doors[k].Direction == 1 & Train.Cars[j].Specs.Doors[k].State > a) {
a = Train.Cars[j].Specs.Doors[k].State;
}
}
}
Function.Stack[s - 1] = a;
} else {
Function.Stack[s - 1] = 0.0;
}
break;
case Instructions.LeftDoorsTarget:
if (Train != null) {
bool q = false;
for (int j = 0; j < Train.Cars.Length; j++) {
if (Train.Cars[j].Specs.AnticipatedLeftDoorsOpened) {
q = true;
break;
}
}
Function.Stack[s] = q ? 1.0 : 0.0;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.LeftDoorsTargetIndex:
if (Train != null) {
bool q = false;
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
for (int k = 0; k < Train.Cars[j].Specs.Doors.Length; k++) {
if (Train.Cars[j].Specs.AnticipatedLeftDoorsOpened) {
q = true;
break;
}
}
}
Function.Stack[s] = q ? 1.0 : 0.0;
} else {
Function.Stack[s - 1] = 0.0;
}
break;
case Instructions.RightDoorsTarget:
if (Train != null) {
bool q = false;
for (int j = 0; j < Train.Cars.Length; j++) {
if (Train.Cars[j].Specs.AnticipatedRightDoorsOpened) {
q = true;
break;
}
}
Function.Stack[s] = q ? 1.0 : 0.0;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.RightDoorsTargetIndex:
if (Train != null) {
bool q = false;
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
for (int k = 0; k < Train.Cars[j].Specs.Doors.Length; k++) {
if (Train.Cars[j].Specs.AnticipatedRightDoorsOpened) {
q = true;
break;
}
}
}
Function.Stack[s] = q ? 1.0 : 0.0;
} else {
Function.Stack[s - 1] = 0.0;
}
break;
// handles
case Instructions.ReverserNotch:
if (Train != null) {
Function.Stack[s] = (double)Train.Specs.CurrentReverser.Driver;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.PowerNotch:
if (Train != null) {
Function.Stack[s] = (double)Train.Specs.CurrentPowerNotch.Driver;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.PowerNotches:
if (Train != null) {
Function.Stack[s] = (double)Train.Specs.MaximumPowerNotch;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.BrakeNotch:
if (Train != null) {
if (Train.Cars[Train.DriverCar].Specs.BrakeType == TrainManager.CarBrakeType.AutomaticAirBrake) {
Function.Stack[s] = (double)Train.Specs.AirBrake.Handle.Driver;
} else {
Function.Stack[s] = (double)Train.Specs.CurrentBrakeNotch.Driver;
}
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.BrakeNotches:
if (Train != null) {
if (Train.Cars[Train.DriverCar].Specs.BrakeType == TrainManager.CarBrakeType.AutomaticAirBrake) {
Function.Stack[s] = 2.0;
} else {
Function.Stack[s] = (double)Train.Specs.MaximumBrakeNotch;
}
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.BrakeNotchLinear:
if (Train != null) {
if (Train.Cars[Train.DriverCar].Specs.BrakeType == TrainManager.CarBrakeType.AutomaticAirBrake) {
if (Train.Specs.CurrentEmergencyBrake.Driver) {
Function.Stack[s] = 3.0;
} else {
Function.Stack[s] = (double)Train.Specs.AirBrake.Handle.Driver;
}
} else if (Train.Specs.HasHoldBrake) {
if (Train.Specs.CurrentEmergencyBrake.Driver) {
Function.Stack[s] = (double)Train.Specs.MaximumBrakeNotch + 2.0;
} else if (Train.Specs.CurrentBrakeNotch.Driver > 0) {
Function.Stack[s] = (double)Train.Specs.CurrentBrakeNotch.Driver + 1.0;
} else {
Function.Stack[s] = Train.Specs.CurrentHoldBrake.Driver ? 1.0 : 0.0;
}
} else {
if (Train.Specs.CurrentEmergencyBrake.Driver) {
Function.Stack[s] = (double)Train.Specs.MaximumBrakeNotch + 1.0;
} else {
Function.Stack[s] = (double)Train.Specs.CurrentBrakeNotch.Driver;
}
}
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.BrakeNotchesLinear:
if (Train != null) {
if (Train.Cars[Train.DriverCar].Specs.BrakeType == TrainManager.CarBrakeType.AutomaticAirBrake) {
Function.Stack[s] = 3.0;
} else if (Train.Specs.HasHoldBrake) {
Function.Stack[s] = Train.Specs.MaximumBrakeNotch + 2.0;
} else {
Function.Stack[s] = Train.Specs.MaximumBrakeNotch + 1.0;
}
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.EmergencyBrake:
if (Train != null) {
Function.Stack[s] = Train.Specs.CurrentEmergencyBrake.Driver ? 1.0 : 0.0;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.HasAirBrake:
if (Train != null) {
Function.Stack[s] = Train.Cars[Train.DriverCar].Specs.BrakeType == TrainManager.CarBrakeType.AutomaticAirBrake ? 1.0 : 0.0;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.HoldBrake:
if (Train != null) {
Function.Stack[s] = Train.Specs.CurrentHoldBrake.Driver ? 1.0 : 0.0;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.HasHoldBrake:
if (Train != null) {
Function.Stack[s] = Train.Specs.HasHoldBrake ? 1.0 : 0.0;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.ConstSpeed:
if (Train != null) {
Function.Stack[s] = Train.Specs.CurrentConstSpeed ? 1.0 : 0.0;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.HasConstSpeed:
if (Train != null) {
Function.Stack[s] = Train.Specs.HasConstSpeed ? 1.0 : 0.0;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
// brake
case Instructions.BrakeMainReservoir:
if (Train != null) {
Function.Stack[s] = Train.Cars[CarIndex].Specs.AirBrake.MainReservoirCurrentPressure;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.BrakeMainReservoirOfCar:
if (Train == null) {
Function.Stack[s - 1] = 0.0;
} else {
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
Function.Stack[s - 1] = Train.Cars[j].Specs.AirBrake.MainReservoirCurrentPressure;
} else {
Function.Stack[s - 1] = 0.0;
}
}
break;
case Instructions.BrakeEqualizingReservoir:
if (Train != null) {
Function.Stack[s] = Train.Cars[CarIndex].Specs.AirBrake.EqualizingReservoirCurrentPressure;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.BrakeEqualizingReservoirOfCar:
if (Train == null) {
Function.Stack[s - 1] = 0.0;
} else {
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
Function.Stack[s - 1] = Train.Cars[j].Specs.AirBrake.EqualizingReservoirCurrentPressure;
} else {
Function.Stack[s - 1] = 0.0;
}
}
break;
case Instructions.BrakeBrakePipe:
if (Train != null) {
Function.Stack[s] = Train.Cars[CarIndex].Specs.AirBrake.BrakePipeCurrentPressure;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.BrakeBrakePipeOfCar:
if (Train == null) {
Function.Stack[s - 1] = 0.0;
} else {
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
Function.Stack[s - 1] = Train.Cars[j].Specs.AirBrake.BrakePipeCurrentPressure;
} else {
Function.Stack[s - 1] = 0.0;
}
}
break;
case Instructions.BrakeBrakeCylinder:
if (Train != null) {
Function.Stack[s] = Train.Cars[CarIndex].Specs.AirBrake.BrakeCylinderCurrentPressure;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.BrakeBrakeCylinderOfCar:
if (Train == null) {
Function.Stack[s - 1] = 0.0;
} else {
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
Function.Stack[s - 1] = Train.Cars[j].Specs.AirBrake.BrakeCylinderCurrentPressure;
} else {
Function.Stack[s - 1] = 0.0;
}
}
break;
case Instructions.BrakeStraightAirPipe:
if (Train != null) {
Function.Stack[s] = Train.Cars[CarIndex].Specs.AirBrake.StraightAirPipeCurrentPressure;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.BrakeStraightAirPipeOfCar:
if (Train == null) {
Function.Stack[s - 1] = 0.0;
} else {
int j = (int)Math.Round(Function.Stack[s - 1]);
if (j < 0) j += Train.Cars.Length;
if (j >= 0 & j < Train.Cars.Length) {
Function.Stack[s - 1] = Train.Cars[j].Specs.AirBrake.StraightAirPipeCurrentPressure;
} else {
Function.Stack[s - 1] = 0.0;
}
}
break;
// safety
case Instructions.SafetyPluginAvailable:
if (Train == TrainManager.PlayerTrain && Train.Plugin != null) {
Function.Stack[s] = TrainManager.PlayerTrain.Plugin.IsDefault ? 0.0 : 1.0;
} else {
Function.Stack[s] = 0.0;
}
s++; break;
case Instructions.SafetyPluginState:
if (Train == null || Train.Plugin == null) {
Function.Stack[s - 1] = 0.0;
} else {
int n = (int)Math.Round(Function.Stack[s - 1]);
if (n >= 0 & n < Train.Plugin.Panel.Length) {
Function.Stack[s - 1] = (double)Train.Plugin.Panel[n];
} else {
Function.Stack[s - 1] = 0.0;
}
} break;
// timetable
case Instructions.TimetableVisible:
Function.Stack[s] = Timetable.CurrentTimetable == Timetable.TimetableState.Custom & Timetable.CustomTimetableAvailable ? 0.0 : -1.0;
s++; break;
// sections
case Instructions.SectionAspectNumber:
if (IsPartOfTrain) {
int nextSectionIndex = Train.CurrentSectionIndex + 1;
if (nextSectionIndex >= 0 & nextSectionIndex < Game.Sections.Length) {
int a = Game.Sections[nextSectionIndex].CurrentAspect;
if (a >= 0 & a < Game.Sections[nextSectionIndex].Aspects.Length) {
Function.Stack[s] = (double)Game.Sections[nextSectionIndex].Aspects[a].Number;
} else {
Function.Stack[s] = 0;
}
}
} else if (SectionIndex >= 0 & SectionIndex < Game.Sections.Length) {
int a = Game.Sections[SectionIndex].CurrentAspect;
if (a >= 0 & a < Game.Sections[SectionIndex].Aspects.Length) {
Function.Stack[s] = (double)Game.Sections[SectionIndex].Aspects[a].Number;
} else {
Function.Stack[s] = 0;
}
} else {
Function.Stack[s] = 0;
}
s++; break;
// default
default:
throw new InvalidOperationException("The unknown instruction " + Function.Instructions[i] + " was encountered in ExecuteFunctionScript.");
}
}
Function.LastResult = Function.Stack[s - 1];
}
// --- functions ---
/// <summary>Gets the intensity of the glow.</summary>
/// <param name="cameraPosition">The position of the camera.</param>
/// <param name="cameraOrientation">The orientation of the camera.</param>
/// <param name="objectPosition">The position of the object.</param>
/// <param name="objectOrientation">The orientation of the object.</param>
/// <returns>The intensity of the glow expressed as a value between 0 and 1.</returns>
public override double GetIntensity(Vector3D cameraPosition, Orientation3 cameraOrientation, Vector3D objectPosition, Vector3D objectOrientation) {
/* The underlying formula for the intensity is
* i = d^2 / (d^2 + h^2)
* where
* i = intensity
* d = distance between object and camera
* h = distance at which intensity is 50% */
double distanceSquared = (objectPosition - cameraPosition).NormSquared();
return distanceSquared / (distanceSquared + this.HalfDistanceSquared);
}
