/** \file turnout.c
* Turnout drawing
*/
/* XTrkCad - Model Railroad CAD
* Copyright (C) 2005 Dave Bullis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "common.h"
#include "common-ui.h"
#include "compound.h"
#include "custom.h"
#include "draw.h"
#include "track.h"
/* Draw turnout data */
/**
* The types of turnouts that get enhanced drawing methods
*/
enum dtoType {
DTO_INVALID,
DTO_NORMAL,
DTO_THREE,
DTO_WYE,
DTO_CURVED,
DTO_XING,
DTO_XNG9,
DTO_SSLIP,
DTO_DSLIP,
DTO_LCROSS,
DTO_RCROSS,
DTO_DCROSS
};
// Define to plot control points (DTO_NORMAL, DTO_CURVED, DTO_XING, DTO_LCROSS)
// #define DTO_DEBUG DTO_XING
#define DTO_DIM 4 // Maximum number of paths
#define DTO_SEGS 24 // Maximum number of control points
static struct DrawToData_t {
TRKINX_T index;
enum dtoType toType;
track_p trk;
tieData_t td;
int bridge;
int roadbed;
int endCnt;
int pathCnt;
int routeCnt;
int strCnt;
int crvCnt;
int rgtCnt;
int lftCnt;
int strPath;
int str2Path;
int crvPath;
int crv2Path;
int origCnt;
int origins[DTO_DIM];
coOrd midPt;
struct extraDataCompound_t* xx;
} dtod;
struct DrawTo_t {
int n;
trkSeg_p trkSeg[DTO_SEGS];
coOrd base[DTO_SEGS];
coOrd baseLast;
DIST_T dy[DTO_SEGS];
ANGLE_T angle;
ANGLE_T crvAngle;
coOrd pts[DTO_SEGS];
coOrd ptsLast;
char type;
};
static struct DrawTo_t dto[DTO_DIM];
/****************************************
*
* Draw Turnout Roadbed
*
*/
int roadbedOnScreen = 0;
void DrawTurnoutRoadbedSide(drawCmd_p d, wDrawColor color, coOrd orig,
ANGLE_T angle, trkSeg_p sp, ANGLE_T side, int first, int last)
{
segProcData_t data;
if (last <= first) {
return;
}
data.drawRoadbedSide.first = first;
data.drawRoadbedSide.last = last;
data.drawRoadbedSide.side = side;
data.drawRoadbedSide.roadbedWidth = roadbedWidth;
data.drawRoadbedSide.rbw = (wDrawWidth)floor(roadbedLineWidth *
(d->dpi / d->scale) + 0.5);
data.drawRoadbedSide.orig = orig;
data.drawRoadbedSide.angle = angle;
data.drawRoadbedSide.color = color;
data.drawRoadbedSide.d = d;
SegProc(SEGPROC_DRAWROADBEDSIDE, sp, &data);
}
static void ComputeAndDrawTurnoutRoadbedSide(
drawCmd_p d,
wDrawColor color,
coOrd orig,
ANGLE_T angle,
trkSeg_p segPtr,
int segCnt,
int segInx,
ANGLE_T side)
{
unsigned long res, res1;
int b0, b1;
res = ComputeTurnoutRoadbedSide(segPtr, segCnt, segInx, side, roadbedWidth);
if (res == 0L) {
} else if (res == 0xFFFFFFFF) {
DrawTurnoutRoadbedSide(d, color, orig, angle, &segPtr[segInx], side, 0, 32);
} else {
for (b0 = 0, res1 = 0x00000001; res1 && (res1 & res); b0++, res1 <<= 1);
for (b1 = 32, res1 = 0x80000000; res1 && (res1 & res); b1--, res1 >>= 1);
DrawTurnoutRoadbedSide(d, color, orig, angle, &segPtr[segInx], side, 0, b0);
DrawTurnoutRoadbedSide(d, color, orig, angle, &segPtr[segInx], side, b1, 32);
}
}
static void DrawTurnoutRoadbed(
drawCmd_p d,
wDrawColor color,
coOrd orig,
ANGLE_T angle,
trkSeg_p segPtr,
int segCnt)
{
int inx, trkCnt = 0, segInx = 0;
for (inx = 0; inx < segCnt; inx++) {
if (IsSegTrack(&segPtr[inx])) {
segInx = inx;
trkCnt++;
if (trkCnt > 1) {
break;
}
}
}
if (trkCnt == 0) {
return;
}
if (trkCnt == 1) {
DrawTurnoutRoadbedSide(d, color, orig, angle, &segPtr[segInx], +90, 0, 32);
DrawTurnoutRoadbedSide(d, color, orig, angle, &segPtr[segInx], -90, 0, 32);
} else {
for (inx = 0; inx < segCnt; inx++) {
if (IsSegTrack(&segPtr[inx])) {
ComputeAndDrawTurnoutRoadbedSide(d, color, orig, angle, segPtr, segCnt, inx,
+90);
ComputeAndDrawTurnoutRoadbedSide(d, color, orig, angle, segPtr, segCnt, inx,
-90);
}
}
}
}
/****************************************
*
* TURNOUT DRAWING
*
*/
/**
* Get the paths from the turnout definition. Puts the results into static dto structure.
* Curved segments are broken up into short sections of the lesser of 5 degrees or 5 * tie spacing.
*
* \param trk track_p pointer to a track
* \param xx pointer to the extraDataCompound struct
*
* \returns the number of paths
*/
int GetTurnoutPaths(track_p trk, struct extraDataCompound_t* xx)
{
wIndex_t segInx;
wIndex_t segEP;
int i;
ANGLE_T a0, a1, aa0, aa1;
DIST_T r, len;
coOrd p0, p1;
PATHPTR_T pp;
dtod.trk = trk;
dtod.index = GetTrkIndex( trk );
dtod.xx = xx;
dtod.td = GetTrkTieData( trk );
int pathCnt = 0, routeCnt = 0;
for (i = 0; i < DTO_DIM; i++) {
dto[i].n = 0;
}
// Validate that the first segment starts at (0, 0)
// and if STR p1.y == 0, if CRV angle == 0 or angle == 180
GetSegInxEP(1, &segInx, &segEP);
trkSeg_p segPtr = &xx->segs[segInx];
switch (segPtr->type) {
case SEG_STRTRK:
p0 = segPtr->u.l.pos[0];
p1 = segPtr->u.l.pos[1];
if ((FindDistance(p0, zero) > EPSILON) || (fabs(p1.y) > EPSILON)) {
return -1;
}
break;
case SEG_CRVTRK:
r = fabs(segPtr->u.c.radius);
a0 = segPtr->u.c.a0;
a1 = segPtr->u.c.a1;
if (segPtr->u.c.radius > 0) {
aa0 = a0;
} else {
aa0 = a0 + a1;
}
PointOnCircle(&p0, segPtr->u.c.center, r, aa0);
if ((FindDistance(p0, zero) > EPSILON)
|| ((fabs(aa0 - 180) > EPSILON) && (fabs(aa0) > EPSILON))) {
return -1;
}
break;
}
pp = GetPaths(trk);
while (pp[0]) {
pp += strlen((char*)pp) + 1;
ANGLE_T angle = 0;
while (pp[0]) {
if (pathCnt < DTO_DIM) {
dto[pathCnt].type = 'S';
while (pp[0]) {
GetSegInxEP(pp[0], &segInx, &segEP);
// trkSeg_p
segPtr = &xx->segs[segInx];
switch (segPtr->type) {
case SEG_STRTRK:
p0 = segPtr->u.l.pos[0];
p1 = segPtr->u.l.pos[1];
wIndex_t n = dto[pathCnt].n;
dto[pathCnt].trkSeg[n] = segPtr;
dto[pathCnt].base[n] = p0;
n++;
dto[pathCnt].trkSeg[n] = segPtr;
dto[pathCnt].base[n] = p1;
// n++;
dto[pathCnt].n = n;
if (n >= DTO_SEGS - 1) { return -1; }
break;
case SEG_CRVTRK:
r = fabs(segPtr->u.c.radius);
dto[pathCnt].type = segPtr->u.c.center.y < 0 ? 'R' : 'L';
a0 = segPtr->u.c.a0;
a1 = segPtr->u.c.a1;
angle += a1;
len = D2R(a1) * r;
// Every 5 degrees or 5 * tie spacing
int cnt = (int)floor(a1 / 5.0);
int cnt2 = (int)floor(len / 5 / dtod.td.spacing);
if (cnt2 > cnt) { cnt = cnt2; }
if (cnt <= 0) { cnt = 1; }
aa1 = a1 / cnt;
if (dto[pathCnt].type == 'R') {
aa0 = a0;
} else {
aa0 = a0 + a1;
aa1 = -aa1;
}
PointOnCircle(&p0, segPtr->u.c.center, r, aa0);
n = dto[pathCnt].n;
dto[pathCnt].trkSeg[n] = segPtr;
dto[pathCnt].base[n] = p0;
n++;
dto[pathCnt].n = n;
while (cnt > 0) {
aa0 += aa1;
PointOnCircle(&p0, segPtr->u.c.center, r, aa0);
// n = dto[pathCnt].n;
dto[pathCnt].trkSeg[n] = segPtr;
dto[pathCnt].base[n] = p0;
n++;
if (n >= DTO_SEGS - 1) { return -1; }
cnt--;
}
n--; // remove that last point count
dto[pathCnt].n = n;
}
pp++;
}
// Include the last point
dto[pathCnt].crvAngle = angle;
dto[pathCnt].n++;
}
pathCnt++;
if (pathCnt > DTO_DIM) { return -1; }
pp++;
}
routeCnt++;
pp++;
}
dtod.pathCnt = pathCnt;
dtod.routeCnt = routeCnt;
dtod.endCnt = GetTrkEndPtCnt( trk );
// Guard value: n < DTO_SEGS - 2
for (i = 0; i < pathCnt; i++) {
dto[i].pts[dto[i].n].x = DIST_INF;
}
return pathCnt;
}
/**
* Sets the turnout type if compatible with enhanced drawing methods. The data is
* from the path data saved in dtod and dto by GetTurnoutPaths. The turnout type is
* stored in the dtod.toType. DTO_INVALID (0) if the enhanced methods cannot handle
* it.
*/
void GetTurnoutType()
{
dtod.strPath = -1;
dtod.str2Path = -1;
dtod.crvPath = -1;
dtod.crv2Path = -1;
dtod.toType = DTO_INVALID;
int strCnt = 0, crvCnt = 0, lftCnt = 0, rgtCnt = 0;
// enum dtoType toType = DTO_INVALID;
int i, j;
// Count path origins
dtod.origCnt = 1;
dtod.origins[0] = 0;
for (i = 1; i < dtod.pathCnt; i++) {
int eq = 0;
for (j = 0; j < i; j++) {
if (CoOrdEqual(dto[dtod.origins[j]].base[0], dto[i].base[0])) {
eq++;
break;
}
}
if (eq == 0) {
if (dtod.origCnt < DTO_DIM) {
dtod.origins[dtod.origCnt] = i;
}
dtod.origCnt++;
}
if (dtod.origCnt >= DTO_DIM) {
return;
}
}
// Determine the path type
for (i = 0; i < dtod.pathCnt; i++) {
switch (dto[i].type) {
case 'S':
strCnt++;
if (strCnt == 1) {
dtod.strPath = i;
} else {
dtod.str2Path = i;
}
break;
case 'L':
lftCnt++;
crvCnt++;
if (crvCnt == 1) {
dtod.crvPath = i;
} else {
dtod.crv2Path = i;
}
break;
case 'R':
rgtCnt++;
crvCnt++;
if (crvCnt == 1) {
dtod.crvPath = i;
} else {
dtod.crv2Path = i;
}
break;
}
}
dtod.strCnt = strCnt;
dtod.crvCnt = crvCnt;
dtod.lftCnt = lftCnt;
dtod.rgtCnt = rgtCnt;
// Normal two- or three-way turnout, or a curved turnout
if (dtod.origCnt == 1) {
if (dtod.pathCnt == 2) {
if (strCnt == 1 && crvCnt == 1) {
dtod.toType = DTO_NORMAL;
} else if ((strCnt == 0) && ((lftCnt == 2) || (rgtCnt == 2))) {
// Assumes outer curve is [0] and inner is [1]
if ((dto[0].crvAngle <= 20) && (dto[1].crvAngle - dto[0].crvAngle <= 15)) {
dtod.toType = DTO_CURVED;
}
} else if (lftCnt == 1 && rgtCnt == 1) {
dtod.toType = DTO_WYE;
}
} else if ((dtod.pathCnt == 3) && (strCnt == 1)
&& (lftCnt == 1) && (rgtCnt == 1)) {
dtod.toType = DTO_THREE;
}
} else
// Crossing, single- and double-slip
if ((dtod.origCnt == 2) && (dtod.endCnt == 4)
&& strCnt == 2) {
ANGLE_T a0, a1, a2;
a1 = FindAngle(dto[dtod.strPath].base[0], dto[dtod.strPath].base[1]);
a2 = FindAngle(dto[dtod.str2Path].base[0], dto[dtod.str2Path].base[1]);
// Swap the ends of the strPath if large angle
if((a1 > 180.0) && (dto[dtod.strPath].n == 2)) {
coOrd tmp = dto[dtod.strPath].base[0];
dto[dtod.strPath].base[0] = dto[dtod.strPath].base[1];
dto[dtod.strPath].base[1] = tmp;
i = dto[dtod.strPath].n - 1;
tmp = dto[dtod.strPath].pts[0];
dto[dtod.strPath].pts[0] = dto[dtod.strPath].pts[i];
dto[dtod.strPath].pts[i] = tmp;
a1 = a1 - 180.0;
dto[dtod.strPath].angle = a1;
}
// Swap the ends of the str2Path if large angle
if((a2 > 180.0) && (dto[dtod.str2Path].n == 2)) {
coOrd tmp = dto[dtod.str2Path].base[0];
dto[dtod.str2Path].base[0] = dto[dtod.str2Path].base[1];
dto[dtod.str2Path].base[1] = tmp;
i = dto[dtod.str2Path].n - 1;
tmp = dto[dtod.str2Path].pts[0];
dto[dtod.str2Path].pts[0] = dto[dtod.str2Path].pts[i];
dto[dtod.str2Path].pts[i] = tmp;
a2 = a2 - 180.0;
dto[dtod.str2Path].angle = a2;
}
a0 = DifferenceBetweenAngles(a1, a2);
if(a0 < 0) {
int tmp = dtod.strPath;
dtod.strPath = dtod.str2Path;
dtod.str2Path = tmp;
a0 = NormalizeAngle(-a0);
}
if ((a0 > 90.0) || (a0 < 0.0)) {
return;
}
coOrd p1 = dto[dtod.strPath].base[0];
coOrd p2 = dto[dtod.str2Path].base[0];
coOrd pos = zero;
int intersect = FindIntersection(&pos, p1, a1, p2, a2);
if (intersect) {
if(strCnt == 2 && dtod.pathCnt == 2) {
if((a0 <= 61) && (a0 >= -61)) {
dtod.toType = DTO_XING;
} else {
dtod.toType = DTO_XNG9;
}
} else if(dtod.pathCnt == 3 && (lftCnt == 1 || rgtCnt == 1)) {
dtod.toType = DTO_SSLIP;
} else if(dtod.pathCnt == 4 && lftCnt == 1 && rgtCnt == 1) {
dtod.toType = DTO_DSLIP;
}
}
// No intersect, it could be a crossover
else if (strCnt == 2) {
if (dtod.pathCnt == 4 && lftCnt == 1 && rgtCnt == 1) {
dtod.toType = DTO_DCROSS;
} else if(dtod.pathCnt == 3) {
// Perverse test because the cross paths go Left then Right, for example
if(lftCnt == 1) {
dtod.toType = DTO_RCROSS;
} else if(rgtCnt == 1) {
dtod.toType = DTO_LCROSS;
} else {
dtod.toType = DTO_INVALID;
}
}
}
}
}
#if 0
/**
* Draw Layout lines and points
*
* \param d The drawing object
* \param scaleInx The layout/track scale index
*/
static void DrawDtoLayout(
drawCmd_p d,
SCALEINX_T scaleInx
)
{
#ifdef DTO_DEBUG
// Draw the points and lines from dto
double r = dtod.td->width / 2;
// if (r < 1) r = 1;
int i, j;
for (i = 0; i < DTO_DIM; i++) {
for (j = 0; j < dto[i].n; j++) {
DrawFillCircle(d, dto[i].pts[j], r, drawColorPurple);
if (j < dto[i].n - 1) {
DrawLine(d, dto[i].pts[j], dto[i].pts[j + 1], 0, drawColorPurple);
}
}
}
#endif
}
#endif
/**
* Use the coOrds to build a polygon and draw the bridge fill. Note that the coordinates are
* passed as pairs, and rearranged into a polygon with the 1,2,4,3 order.
*
* \param d The drawing object
* \param c The color
* \param b1 The first coordinate
* \param b2 The second coordinate
* \param b3 The third coordinate
* \param b4 The fourth coordinate
*/
static void DrawFill(
drawCmd_p d,
wDrawColor c,
coOrd b1,
coOrd b2,
coOrd b3,
coOrd b4
)
{
coOrd p[4] = {b1, b2, b4, b3};
DrawPoly(d,4,p,NULL,c,0,DRAW_FILL );
}
/**
* Draw Bridge parapets and background or Roadbed for a turnout
*
* \param d The drawing object
* \param fillType 0 for bridge, 1 for roadbed
* \param path1 The first path
* \param path2 The second path
*/
static void DrawTurnoutFill(
drawCmd_p d,
int fillType,
int path1,
int path2
)
{
DIST_T trackGauge = GetTrkGauge(dtod.trk);
wDrawWidth width2 = (wDrawWidth)round((2.0 * d->dpi) / BASE_DPI);
if (d->options&DC_PRINT) {
width2 = (wDrawWidth)round(d->dpi / BASE_DPI);
}
wDrawColor color = (fillType==0?bridgeColor:roadbedColor);
double fillWidth = 1.5;
coOrd b1,b2,b3,b4,b5,b6;
ANGLE_T angle = dtod.xx->angle,a = 0.0;
int i,j,i1,i2;
i1 = path1;
i2 = path2;
if(dto[i1].base[dto[i1].n - 1].y < dto[i2].base[dto[i2].n - 1].y) {
i1 = path2;
i2 = path1;
// a = -a;
}
if(dtod.toType == DTO_THREE) {
i = dtod.strPath;
DIST_T dy = fabs(dto[i].dy[0]) + trackGauge * fillWidth;
b1 = dto[i].pts[0];
Translate(&b3,b1,(angle + a),dy);
b1 = dto[i].pts[dto[i].n - 1];
Translate(&b4,b1,(angle + a),dy);
b2 = dto[i].pts[0];
Translate(&b5,b2,(angle + a),-dy);
b2 = dto[i].pts[dto[i].n - 1];
Translate(&b6,b2,(angle + a),-dy);
// Draw the background
DrawFill(d,color,b3,b4,b5,b6);
}
for(i = i1; 1; i = i2,a = 180.0) {
DIST_T dy = fabs(dto[i].dy[0]) + trackGauge * fillWidth;
b1 = dto[i].pts[0];
Translate(&b3,b1,(angle + a),dy);
Translate(&b5,b1,(angle + a),-(dy * 0.75));
for(j = 1; j < dto[i].n; j++) {
dy = fabs(dto[i].dy[j]) + trackGauge * fillWidth;
b2 = dto[i].pts[j];
Translate(&b4,b2,(angle + a),dy);
Translate(&b6,b2,(angle + a),-(dy * 0.75));
// Draw the background
DrawFill(d,color,b3,b4,b5,b6);
// Draw the bridge edge
if(fillType==0) {
DrawLine( d,b3,b4,width2,drawColorBlack );
}
b1 = b2;
b3 = b4;
b5 = b6;
}
if(i == i2) {
break;
}
}
EPINX_T ep;
coOrd p;
track_p trk1;
coOrd p0,p1;
// Bridge parapet ends
if(fillType==0) {
for(ep = 0; ep < 3; ep++) {
trk1 = GetTrkEndTrk(dtod.trk,ep);
if((trk1) && (!GetTrkBridge(trk1))) {
p = GetTrkEndPos(dtod.trk,ep);
a = GetTrkEndAngle(dtod.trk,ep) + 90.0;
int i = (dtod.lftCnt > 0) && (dtod.rgtCnt == 0) ? 2 : 1;
if(ep != i) {
Translate(&p0,p,a,trackGauge * 1.5);
Translate(&p1,p0,a - 45.0,trackGauge * 1.5);
DrawLine(d,p0,p1,width2,drawColorBlack);
}
if(ep != (3 - i)) {
Translate(&p0,p,a,-trackGauge * 1.5);
Translate(&p1,p0,a + 45.0,-trackGauge * 1.5);
DrawLine(d,p0,p1,width2,drawColorBlack);
}
}
}
}
}
/**
* Draw Bridge parapets and background or Roadbed for a cross-over
*
* \param d The drawing object
* \param fillType 0 for bridge, 1 for roadbed
* \param path1 The first path, straight
* \param path2 The second path, straight
*/
static void DrawCrossFill(
drawCmd_p d,
int fillType,
int path1,
int path2
)
{
DIST_T trackGauge = GetTrkGauge(dtod.trk);
wDrawWidth width2 = (wDrawWidth)round((2.0 * d->dpi)/BASE_DPI);
if (d->options&DC_PRINT) {
width2 = (wDrawWidth)round(d->dpi / BASE_DPI);
}
wDrawColor color = (fillType==0?bridgeColor:roadbedColor);
double fillWidth = 1.5;
coOrd b1, b2, b3, b4, b5, b6;
ANGLE_T angle = dtod.xx->angle, a = 0.0;
int i1, i2;
i1 = path1;
i2 = path2;
if(dto[i1].base[dto[i1].n - 1].y < dto[i2].base[dto[i2].n - 1].y) {
i1 = path2;
i2 = path1;
// a = -a;
}
DIST_T dy = fabs(dto[i1].dy[0]) + trackGauge * fillWidth;
b1 = dto[i1].pts[0];
Translate(&b3,b1,(angle + a),dy);
b1 = dto[i1].pts[dto[i1].n-1];
Translate(&b4,b1,(angle + a),dy);
b2 = dto[i2].pts[0];
Translate(&b5,b2,(angle + a),-dy);
b2 = dto[i2].pts[dto[i2].n-1];
Translate(&b6,b2,(angle + a),-dy);
// Draw the background
DrawFill(d, color, b3, b4, b5, b6);
// Draw the bridge edges
if(fillType == 0) {
DrawLine(d,b3,b4,width2,drawColorBlack);
DrawLine(d,b5,b6,width2,drawColorBlack);
}
EPINX_T ep;
coOrd p;
track_p trk1;
coOrd p0,p1;
// Bridge parapet ends
if(fillType==0) {
for(ep = 0; ep < 4; ep++) {
trk1 = GetTrkEndTrk(dtod.trk,ep);
if((trk1) && (!GetTrkBridge(trk1))) {
p = GetTrkEndPos(dtod.trk,ep);
a = GetTrkEndAngle(dtod.trk,ep) + 90.0;
if((ep == 1) || (ep == 2)) {
Translate(&p0,p,a,trackGauge * 1.5);
Translate(&p1,p0,a - 45.0,trackGauge * 1.5);
DrawLine(d,p0,p1,width2,drawColorBlack);
}
if((ep == 0) || (ep == 3)) {
Translate(&p0,p,a,-trackGauge * 1.5);
Translate(&p1,p0,a + 45.0,-trackGauge * 1.5);
DrawLine(d,p0,p1,width2,drawColorBlack);
}
}
}
}
}
/**
* Draw Bridge parapets and background or Roadbed for a crossing
*
* \param d The drawing object
* \param fillType 0 for bridge, 1 for roadbed
* \param path1 The first path
* \param path2 The second path
*/
static void DrawXingFill(
drawCmd_p d,
int fillType,
int path1,
int path2
)
{
DIST_T trackGauge = GetTrkGauge(dtod.trk);
wDrawWidth width2 = (wDrawWidth)round((2.0 * d->dpi)/BASE_DPI);
if (d->options&DC_PRINT) {
width2 = (wDrawWidth)round(d->dpi / BASE_DPI);
}
double fillWidth = 1.5;
coOrd b0, b1, b2, b3, b4, b5, b6;
int i, j, i1, i2;
i1 = dtod.strPath;
i2 = dtod.str2Path;
// Fill both straight sections
wDrawWidth width3 = (wDrawWidth)round(trackGauge * 2 * fillWidth * d->dpi /
d->scale);
wDrawColor color = (fillType==0?bridgeColor:roadbedColor);
b1 = dto[i1].pts[0];
b2 = dto[i1].pts[dto[i1].n-1];
DrawLine(d,b1,b2,width3,color);
b1 = dto[i2].pts[0];
b2 = dto[i2].pts[dto[i1].n-1];
DrawLine(d,b1,b2,width3,color);
i1 = path1;
i2 = path2;
if(dto[i1].base[dto[i1].n - 1].y < dto[i2].base[dto[i2].n - 1].y) {
i1 = path2;
i2 = path1;
}
// Handle curved sections for slips
BOOL_T hasLeft = 0, hasRgt = 0;
ANGLE_T angle = dtod.xx->angle, a = 0.0;
for(i = i1; 1; i = i2,a = 180.0) {
DIST_T dy = fabs(dto[i].dy[0]) + trackGauge * fillWidth;
b1 = dto[i].pts[0];
Translate(&b3,b1,(angle + a),dy);
Translate(&b5,b1,(angle + a),-(dy * 0.75));
if(dto[i].type != 'S') {
if(dto[i].type == 'L') {
hasLeft = 1;
} else if(dto[i].type == 'R') {
hasRgt = 1;
}
for(j = 1; j < dto[i].n; j++) {
dy = fabs(dto[i].dy[j]) + trackGauge * fillWidth;
b2 = dto[i].pts[j];
Translate(&b4,b2,(angle + a),dy);
Translate(&b6,b2,(angle + a),-(dy * 0.75));
// Draw the background
DrawFill(d,color,b3,b4,b5,b6);
// Draw the bridge edge
if(fillType==0) {
DrawLine( d,b3,b4,width2,drawColorBlack );
}
b1 = b2;
b3 = b4;
b5 = b6;
}
}
if(i == i2) {
break;
}
}
if(dtod.strPath >= 0 && dtod.str2Path >= 0) {
i1 = dtod.strPath;
i2 = dtod.str2Path;
if(!hasRgt&&fillType==0) {
DIST_T dy = trackGauge * 1.5;
ANGLE_T a1, a2;
b1 = dto[i1].pts[0];
a1 = dto[i1].angle + 90;
Translate(&b3,b1,a1,dy);
b2 = dto[i2].pts[dto[i2].n - 1];
a2 = dto[i2].angle + 90;
Translate(&b4,b2,a2,dy);
FindIntersection(&b0, b3, a1-90.0, b4, a2-90.0);
// Draw the bridge edge
DrawLine(d,b3,b0,width2,drawColorBlack);
DrawLine(d,b0,b4,width2,drawColorBlack);
}
if(!hasLeft&&fillType==0) {
DIST_T dy = trackGauge * 1.5;
ANGLE_T a1, a2;
b1 = dto[i2].pts[0];
a1 = dto[i2].angle - 90;
Translate(&b3,b1,a1,dy);
b2 = dto[i1].pts[dto[i1].n - 1];
a2 = dto[i1].angle - 90;
Translate(&b4,b2,a2,dy);
FindIntersection(&b0, b3, a1+90.0, b4, a2+90.0);
// Draw the bridge edge
DrawLine(d,b3,b0,width2,drawColorBlack);
DrawLine(d,b0,b4,width2,drawColorBlack);
}
if(dtod.toType == DTO_XNG9 && fillType==0) {
DIST_T dy = trackGauge * 1.5;
ANGLE_T a1, a2;
b1 = dto[i1].pts[dto[i1].n - 1];
a1 = dto[i1].angle + 90;
Translate(&b3,b1,a1,dy);
b2 = dto[i2].pts[dto[i2].n - 1];
a2 = dto[i2].angle - 90;
Translate(&b4,b2,a2,dy);
FindIntersection(&b0, b3, a1-90.0, b4, a2+90.0);
// Draw the bridge edge
DrawLine(d,b3,b0,width2,drawColorBlack);
DrawLine(d,b0,b4,width2,drawColorBlack);
b1 = dto[i1].pts[0];
a1 = dto[i1].angle - 90;
Translate(&b3,b1,a1,dy);
b2 = dto[i2].pts[0];
a2 = dto[i2].angle + 90;
Translate(&b4,b2,a2,dy);
FindIntersection(&b0, b3, a1+90.0, b4, a2-90.0);
// Draw the bridge edge
DrawLine(d,b3,b0,width2,drawColorBlack);
DrawLine(d,b0,b4,width2,drawColorBlack);
}
}
// Bridge wings
EPINX_T ep;
coOrd p;
track_p trk1;
coOrd p0,p1;
if(fillType==0) {
for(ep = 0; ep < 4; ep++) {
trk1 = GetTrkEndTrk(dtod.trk,ep);
if((trk1) && (!GetTrkBridge(trk1))) {
p = GetTrkEndPos(dtod.trk,ep);
a = GetTrkEndAngle(dtod.trk,ep) + 90.0;
if((dtod.toType == DTO_XNG9) || (ep == 2) || (ep == 3)) {
Translate(&p0,p,a,trackGauge * 1.5);
Translate(&p1,p0,a - 45.0,trackGauge * 1.5);
DrawLine(d,p0,p1,width2,drawColorBlack);
}
if((dtod.toType == DTO_XNG9) || (ep == 0) || (ep == 1)) {
Translate(&p0,p,a,-trackGauge * 1.5);
Translate(&p1,p0,a + 45.0,-trackGauge * 1.5);
DrawLine(d,p0,p1,width2,drawColorBlack);
}
}
}
}
}
/**
* Init Normal Turnout data structure
* Calculates the dy value of each segment
* Sets pts values REORIGIN base to actual position and angle
* Save often used last base and last point coOrd
*/
static void DrawDtoInit()
{
struct extraDataCompound_t* xx = dtod.xx;
coOrd p1;
int i, j;
for(i = 0; i < DTO_DIM; i++) {
int n = dto[i].n;
for(j = 0; j < n; j++) {
REORIGIN(p1,dto[i].base[j],xx->angle,xx->orig);
dto[i].pts[j] = p1;
if(j < n - 1) {
dto[i].dy[j] = (dto[i].base[j + 1].y - dto[i].base[j].y) /
(dto[i].base[j + 1].x - dto[i].base[j].x);
}
}
dto[i].ptsLast = dto[i].pts[n - 1];
dto[i].baseLast = dto[i].base[n - 1];
}
}
/**
* Draw Normal (Single Origin) Turnout Bridge and Ties. Uses the static dto and dtod structures.
*
* \param d The drawing object
* \param scaleInx The layout/track scale index
* \param color The tie color. If black the color is read from the global tieColor.
*/
static void DrawNormalTurnout(
drawCmd_p d,
SCALEINX_T scaleInx,
BOOL_T omitTies,
wDrawColor color)
{
DIST_T len;
coOrd pos;
int cnt;
ANGLE_T angle;
coOrd s1, s2, p1, p2, q1, q2;
int p0, q0;
// int s0;
ANGLE_T a0;
if (color == wDrawColorBlack) {
color = tieColor;
}
// DIST_T trackGauge = GetTrkGauge(dtod.trk);
DrawDtoInit();
// draw the points
#ifdef DTO_DEBUG
if (DTO_DEBUG == DTO_NORMAL) { DrawDtoLayout(d, scaleInx); }
#endif
int strPath = dtod.strPath, othPath = 0, secPath = 1;
int toType = dtod.toType;
// int first = 1;
switch (toType) {
case DTO_NORMAL:
othPath = 1 - strPath;
secPath = strPath;
break;
case DTO_WYE:
// strPath = 2;
othPath = 0; secPath = 1;
break;
case DTO_THREE:
switch (strPath) {
case 0:
othPath = 1; secPath = 2;
break;
case 1:
othPath = 0; secPath = 2;
break;
case 2:
othPath = 0; secPath = 1;
break;
}
break;
}
if(dtod.bridge) {
DrawTurnoutFill(d,0,othPath,secPath);
} else if(dtod.roadbed) {
DrawTurnoutFill( d,1,othPath,secPath );
}
if (omitTies) {
return;
}
// Straight vector for tie angle
if (toType == DTO_WYE) {
s1 = dto[othPath].pts[0];
s2 = MidPtCoOrd(dto[othPath].ptsLast, dto[secPath].ptsLast);
} else {
s1 = dto[strPath].pts[0];
s2 = dto[strPath].ptsLast;
}
// Diverging vector(s)
p1 = dto[othPath].pts[0];
p2 = dto[othPath].ptsLast;
q1 = dto[secPath].pts[0];
q2 = dto[secPath].ptsLast;
len = FindDistance(s1, s2);
angle = FindAngle(s1, s2); // The straight segment
cnt = (int)floor(len / dtod.td.spacing + 0.5);
if (cnt > 0) {
int pn = dto[othPath].n;
int qn = dto[secPath].n;
DIST_T dx = len / cnt;
/*s0 =*/ p0 = q0 = 0;
DIST_T tdlen = dtod.td.length;
DIST_T tdmax = (toType == DTO_WYE) ? 2.0 * tdlen : 2.5 * tdlen;
DIST_T tdwid = dtod.td.width;
DIST_T px = len, dlenx = dx / 2;
cnt = cnt > 1 ? cnt - 1 : 1;
for (px = dlenx; cnt; cnt--, px += dx) {
if (px >= dto[othPath].base[p0 + 1].x) { p0++; }
if (px >= dto[secPath].base[q0 + 1].x) { q0++; }
if (p0 >= pn || q0 >= qn) {
break;
}
if ((px + dx >= dto[othPath].baseLast.x)
|| (px + dx >= dto[secPath].baseLast.x)) {
break;
}
DIST_T dy1 = dto[othPath].base[p0].y + (px - dto[othPath].base[p0].x) *
dto[othPath].dy[p0];
DIST_T dy2 = dto[secPath].base[q0].y + (px - dto[secPath].base[q0].x) *
dto[secPath].dy[q0];
tdlen = dtod.td.length + fabs(dy1) + fabs(dy2);
if (tdlen > tdmax) {
break;
}
DIST_T dy = dy1 + dy2;
Translate(&pos, s1, angle, px);
Translate(&pos, pos, (angle - 90.0), dy / 2);
DrawTie(d, pos, angle, tdlen, tdwid, color, tieDrawMode == TIEDRAWMODE_SOLID);
}
// Asymmetric? Use longer ties for remaining two tracks (strPath, othPath)
DIST_T sx = px; // Save these values for second code block
int s0 = p0;
if((dtod.toType == DTO_THREE) && (px + dx >= dto[secPath].baseLast.x)) {
for ( ; cnt; cnt--, px += dx) {
if (px >= dto[othPath].base[p0 + 1].x) { p0++; }
// if (px >= dto[secPath].base[q0 + 1].x) q0++;
if (p0 >= pn) {
break;
}
if (px + dx >= dto[othPath].baseLast.x) {
break;
}
DIST_T dy1 = dto[othPath].base[p0].y + (px - dto[othPath].base[p0].x) *
dto[othPath].dy[p0];
tdlen = dtod.td.length + fabs(dy1);
if (tdlen > tdmax) {
break;
}
DIST_T dy = dy1;
Translate(&pos, s1, angle, px);
Translate(&pos, pos, (angle - 90.0), dy / 2);
DrawTie(d, pos, angle, tdlen, tdwid, color, tieDrawMode == TIEDRAWMODE_SOLID);
}
}
// Draw remaining ties, if any
if (px + dx < dto[othPath].baseLast.x) {
p1 = dto[othPath].pts[p0];
p2 = dto[othPath].ptsLast;
angle = FindAngle(p1, p2);
a0 = FindAngle(dto[othPath].base[p0], dto[othPath].baseLast);
DIST_T lenr = (dto[othPath].baseLast.x - px + dlenx) / cos(D2R(90.0 - a0));
Translate(&p1, p2, angle, -lenr);
DrawStraightTies(d, dtod.td, p1, p2, color);
} else {
p1 = dto[othPath].pts[pn - 2];
a0 = FindAngle(p1, p2);
Translate(&pos, p2, a0, -dx / 2);
DrawTie(d, pos, a0, dtod.td.length, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
}
// Restore saved values
if(dtod.toType == DTO_THREE) {
px = sx;
p0 = s0;
}
// Asymmetric? Use longer ties for remaining two tracks (strPath, secPath)
if((dtod.toType == DTO_THREE) && (px + dx >= dto[othPath].baseLast.x)) {
for ( ; cnt; cnt--, px += dx) {
// if (px >= dto[othPath].base[p0 + 1].x) p0++;
if (px >= dto[secPath].base[q0 + 1].x) { q0++; }
if (q0 >= qn) {
break;
}
if (px + dx >= dto[secPath].baseLast.x) {
break;
}
DIST_T dy1 = dto[secPath].base[q0].y + (px - dto[secPath].base[q0].x) *
dto[secPath].dy[q0];
tdlen = dtod.td.length + fabs(dy1);
if (tdlen > tdmax) {
break;
}
DIST_T dy = dy1;
Translate(&pos, s1, angle, px);
Translate(&pos, pos, (angle - 90.0), dy / 2);
DrawTie(d, pos, angle, tdlen, tdwid, color, tieDrawMode == TIEDRAWMODE_SOLID);
}
}
if (px + dx < dto[secPath].baseLast.x) {
q1 = dto[secPath].pts[q0];
q2 = dto[secPath].ptsLast;
angle = FindAngle(q1, q2);
a0 = FindAngle(dto[secPath].base[q0], dto[secPath].baseLast);
DIST_T lenr = (dto[secPath].baseLast.x - px + dlenx) / cos(D2R(90.0 - a0));
Translate(&q1, q2, angle, -lenr);
DrawStraightTies(d, dtod.td, q1, q2, color);
} else {
q1 = dto[secPath].pts[qn - 2];
a0 = FindAngle(q1, q2);
Translate(&pos, q2, a0, -dx / 2);
DrawTie(d, pos, a0, dtod.td.length, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
}
// Final ties at end
if (dtod.toType == DTO_THREE) {
int n = (int)(dto[strPath].baseLast.x);
if (px + dx < len) {
angle = FindAngle(s1, s2);
DIST_T lenr = len - px + dlenx;
Translate(&s1, s2, angle, -lenr);
DrawStraightTies(d, dtod.td, s1, s2, color);
} else {
n = dto[strPath].n;
s1 = dto[strPath].pts[n - 2];
a0 = FindAngle(s1, s2);
Translate(&pos, s2, a0, -dx / 2);
DrawTie(d, pos, a0, dtod.td.length, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
}
}
}
}
/**
* Draw Curved (Single Origin) Turnout Bridge and Ties. Uses the static dto and dtod structures.
*
* \param d The drawing object
* \param scaleInx The layout/track scale index
* \param color The tie color. If black the color is read from the global tieColor.
*/
static void DrawCurvedTurnout(
drawCmd_p d,
SCALEINX_T scaleInx,
BOOL_T omitTies,
wDrawColor color)
{
DIST_T len, r;
coOrd pos;
int cnt;
ANGLE_T angle, dang;
coOrd center;
coOrd p1, p2, q1, q2;
ANGLE_T a0, a1, a2;
struct extraDataCompound_t* xx = dtod.xx;
if (color == wDrawColorBlack) {
color = tieColor;
}
DrawDtoInit();
// draw the points
#ifdef DTO_DEBUG
if (DTO_DEBUG == DTO_CURVED) { DrawDtoLayout(d, scaleInx); }
#endif
int othPath = 0, secPath = 1;
// int toType = dtod.toType;
if(dtod.bridge) {
DrawTurnoutFill(d,0,othPath,secPath);
} else if(dtod.roadbed) {
DrawTurnoutFill(d,1,othPath,secPath);
}
if (omitTies) {
return;
}
// Save the ending coordinates
coOrd othEnd = zero, secEnd = zero;
trkSeg_p trk;
DIST_T tdlen = dtod.td.length, tdmax = tdlen * 2.5;
DIST_T tdspc = dtod.td.spacing, tdspc2 = tdspc / 2.0;
DIST_T tdwid = dtod.td.width;
// double rdot = tdwid / 2;
int pn = dto[othPath].n;
int qn = dto[secPath].n;
int p0 = 0, q0 = 0;
DIST_T px = 0, qx = 0, dy = 0, dy1 = 0, dy2 = 0;
double cosAdj = 1.0;
angle = 0;
px = tdspc2;
qx = tdspc2;
int segs = max(dto[othPath].n, dto[secPath].n);
for (; segs > 0; segs--) {
if (px >= dto[othPath].base[p0 + 1].x) {
p0++;
}
if (qx >= dto[secPath].base[q0 + 1].x) {
q0++;
}
if ((p0 >= pn - 1) || (q0 >= qn - 1)) {
break;
}
trk = dto[othPath].trkSeg[p0];
if (trk->type == SEG_CRVTRK) {
center = trk->u.c.center;
r = fabs(trk->u.c.radius);
a0 = NormalizeAngle(trk->u.c.a0 + dtod.xx->angle);
a1 = trk->u.c.a1;
pos = center;
REORIGIN(center, pos, xx->angle, xx->orig);
len = r * D2R(a1);
cnt = (int)floor(len / tdspc + 0.5);
if (len - tdspc * cnt >= tdspc2) {
cnt++;
}
DIST_T tdlen = dtod.td.length;
// DIST_T dx = len / cnt, dx2 = dx / 2;
if (cnt != 0) {
dang = (len / cnt) * 360 / (2 * M_PI * r);
DIST_T dx = len / cnt, dx2 = dx / 2;
if (dto[othPath].type == 'R') {
a2 = a0 + dang / 2;
} else {
a2 = a0 + a1 - dang / 2;
dang = -dang;
}
angle += fabs(dang / 2);
cosAdj = fabs(cos(D2R(angle)));
px += dx2 * cosAdj;
qx += dx2 * cosAdj;
for (; cnt; cnt--, a2 += dang, angle += dang) {
if (px >= dto[othPath].base[p0 + 1].x) {
p0++;
}
if (qx >= dto[secPath].base[q0 + 1].x) {
q0++;
}
if ((p0 >= pn - 1) || (q0 >= qn - 1)) {
break;
}
coOrd e1, e2;
PointOnCircle(&e1, center, r, a2);
q1 = dto[secPath].pts[q0];
q2 = dto[secPath].pts[q0 + 1];
FindIntersection(&e2, e1, a2, q1, FindAngle(q1, q2));
dy = FindDistance(e1, e2);
DIST_T tlen = tdlen + dy;
if (tlen > tdmax) {
break;
}
Translate(&pos, e1, a2, -dy / 2);
DrawTie(d, pos, angle + xx->angle + 90, tlen, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
// Assures that these ends are the last point drawn before break
othEnd = e1;
secEnd = e2;
cosAdj = fabs(cos(D2R(angle)));
if (cnt > 1) {
px += dx * cosAdj;
qx += dx * cosAdj;
} else {
px += dx2 * cosAdj;
qx += dx2 * cosAdj;
}
}
}
} else {
cosAdj = fabs(cos(D2R(angle)));
p1 = dto[othPath].base[p0];
p2 = dto[othPath].base[p0 + 1];
len = FindDistance(p1, p2);
cnt = (int)floor(len / tdspc + 0.6);
if (cnt > 0) {
DIST_T dx = len / cnt/*, dx2 = dx / 2*/;
for (; cnt; cnt--) {
if (px >= dto[othPath].base[p0 + 1].x) {
p0++;
}
if (qx >= dto[secPath].base[q0 + 1].x) {
q0++;
}
if ((p0 >= pn - 1) || (q0 >= qn - 1)) {
break;
}
p1 = dto[othPath].base[p0];
p2 = dto[othPath].base[p0 + 1];
if ((px >= dto[othPath].baseLast.x)
|| (qx >= dto[secPath].baseLast.x)) {
break;
}
dy1 = dto[secPath].base[q0].y + (qx - dto[secPath].base[q0].x) *
dto[secPath].dy[q0];
dy2 = dto[othPath].base[p0].y + (px - dto[othPath].base[p0].x) *
dto[othPath].dy[p0];
dy = dy1 - dy2;
DIST_T tlen = tdlen + fabs(cosAdj * dy);
if (tlen > tdmax) {
break;
}
q1 = dto[secPath].pts[q0];
q2 = dto[secPath].pts[q0 + 1];
a1 = FindAngle(q1, q2);
DIST_T xlen = qx - dto[secPath].base[q0].x;
Translate(&pos, q1, a1, xlen);
secEnd = pos;
q1 = dto[othPath].pts[p0];
q2 = dto[othPath].pts[p0 + 1];
a1 = FindAngle(q1, q2);
xlen = px - dto[othPath].base[p0].x;
Translate(&pos, q1, a1, xlen);
othEnd = pos;
Translate(&pos, pos, (a1 - 90.0), dy / 2);
DrawTie(d, pos, a1, tlen, tdwid, color, tieDrawMode == TIEDRAWMODE_SOLID);
cosAdj = fabs(cos(D2R(angle)));
px += dx * cosAdj;
qx += dx * cosAdj;
}
} else {
break;
}
}
}
#ifdef DTO_DEBUG
if (DTO_DEBUG == DTO_CURVED) {
DrawFillCircle(d, othEnd, rdot, drawColorGreen);
DrawFillCircle(d, secEnd, rdot, drawColorGreen);
DrawFillCircle(d, dto[othPath].pts[p0], rdot, drawColorBlue);
DrawFillCircle(d, dto[secPath].pts[q0], rdot, drawColorBlue);
}
#endif
// Draw remaining ties, if any
p1 = othEnd;
p2 = dto[othPath].ptsLast;
a0 = FindAngle(p1, p2);
len = FindDistance(p1, p2);
if (len >= 2 * tdspc) {
Translate(&p1, p1, a0, tdspc2);
DrawStraightTies(d, dtod.td, p1, p2, color);
} else if (len > tdspc2) {
Translate(&p2, p2, a0, -tdspc2);
DrawTie(d, p2, a0, dtod.td.length, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
}
q1 = secEnd;
q2 = dto[secPath].ptsLast;
a0 = FindAngle(q1, q2);
len = FindDistance(q1, q2);
if (len >= 2 * tdspc) {
Translate(&q1, q1, a0, tdspc2);
DrawStraightTies(d, dtod.td, q1, q2, color);
} else if (len > tdspc2) {
Translate(&q2, q2, a0, -tdspc2);
DrawTie(d, q2, a0, dtod.td.length, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
}
}
/**
* Draw Crossing and Slip Turnout Bridge and Ties - Uses the static dto and dtod structures.
*
* \param d The drawing object
* \param scaleInx The layout/track scale index
* \param color The tie color. If black the color is read from the global tieColor.
*/
static void DrawXingTurnout(
drawCmd_p d,
SCALEINX_T scaleInx,
BOOL_T omitTies,
wDrawColor color)
{
DIST_T len;
coOrd pos;
int cnt;
ANGLE_T cAngle;
if (color == wDrawColorBlack) {
color = tieColor;
}
coOrd c1, c2, s1, s2, p1, p2, q1;
int p0, q0;
ANGLE_T a0, a1, a2;
int strPath = dtod.strPath, str2Path = dtod.str2Path;
struct extraDataCompound_t* xx = dtod.xx;
DrawDtoInit();
dto[strPath].angle = FindAngle(dto[strPath].pts[0], dto[strPath].ptsLast);
dto[str2Path].angle = FindAngle(dto[str2Path].pts[0], dto[str2Path].ptsLast);
int othPath = strPath, secPath = str2Path;
int toType = dtod.toType;
int i, j;
switch (toType) {
case DTO_XING:
case DTO_XNG9:
break;
case DTO_SSLIP:
for (i = 0; i < dtod.pathCnt; i++) {
if (dto[i].type == 'L' || dto[i].type == 'R') {
secPath = i;
break;
}
}
break;
case DTO_DSLIP:
for (i = 0; i < dtod.pathCnt; i++) {
if (dto[i].type == 'L') {
othPath = i;
} else if (dto[i].type == 'R') {
secPath = i;
}
}
break;
}
if(dtod.bridge) {
DrawXingFill(d,0,othPath,secPath);
} else if(dtod.roadbed) {
DrawXingFill(d,1,othPath,secPath);
}
// draw the points
#ifdef DTO_DEBUG
if (DTO_DEBUG == DTO_XING) { DrawDtoLayout(d, scaleInx); }
#endif
if (omitTies) {
return;
}
DIST_T tdlen = dtod.td.length, tdmax = 2.0 * tdlen;
DIST_T tdwid = dtod.td.width;
DIST_T tdspc = dtod.td.spacing, tdspc2 = tdspc / 2;
// Midpoint
p1 = dto[strPath].pts[0];
a1 = dto[strPath].angle;
q1 = dto[str2Path].pts[0];
a2 = dto[str2Path].angle;
FindIntersection(&pos, p1, a1, q1, a2);
dtod.midPt = pos;
#ifdef DTO_DEBUG
if(DTO_DEBUG == DTO_XING) {
double r = td->width / 2;
DrawFillCircle(d,p1,r,drawColorPurple);
DrawFillCircle(d,q1,r,drawColorPurple);
DrawFillCircle(d,dtod.midPt,r,drawColorPurple);
}
#endif
// Tie length adjust
double dAngle = fabs(DifferenceBetweenAngles(a1, a2));
double magic = 1.0;
// Short circuit the complex code for this simple case
if (toType == DTO_XNG9) {
p1 = dto[strPath].pts[0];
p2 = dto[strPath].ptsLast;
DrawStraightTies(d, dtod.td, p1, p2, color);
p1 = dto[str2Path].pts[0];
p2 = dto[str2Path].ptsLast;
// Omit the center ties
magic = 1 / cos(D2R(90 - dAngle));
DIST_T tdadj = (tdlen / 2) * magic;
DIST_T tdadj2 = tdspc2 * magic;
dAngle = (dAngle - 90) / 2;
Translate(&pos, dtod.midPt, a2, -tdadj - tdadj2);
DrawTie(d, pos, a2 - dAngle, tdlen, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
Translate(&pos, dtod.midPt, a2, -tdadj - tdspc);
DrawStraightTies(d, dtod.td, p1, pos, color);
Translate(&pos, dtod.midPt, a2, tdadj + tdadj2);
DrawTie(d, pos, a2 - dAngle, tdlen, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
Translate(&pos, dtod.midPt, a2, tdadj + tdspc);
DrawStraightTies(d, dtod.td, pos, p2, color);
return;
}
// Straight vector for tie angle
s1 = MidPtCoOrd(dto[strPath].base[0], dto[str2Path].base[0]);
s2 = MidPtCoOrd(dto[strPath].baseLast, dto[str2Path].baseLast);
// Rotate base coordinates so that the tie line is aligned with x-axis and origin is at zero
cAngle = FindAngle(s1, s2);
for (i = 0; i < DTO_DIM; i++)
for (j = 0; j < dto[i].n; j++) {
dto[i].base[j].x -= s1.x;
dto[i].base[j].y -= s1.y;
Rotate(&dto[i].base[j], zero, (90.0 - cAngle));
}
for (i = 0; i < DTO_DIM; i++) {
for (j = 0; j < dto[i].n - 1; j++) {
dto[i].dy[j] = (dto[i].base[j + 1].y - dto[i].base[j].y) /
(dto[i].base[j + 1].x - dto[i].base[j].x);
}
if (dto[i].type == 'S') {
dto[i].angle = FindAngle(dto[i].pts[0], dto[i].ptsLast);
}
}
// Tie center line in drawing coordinates
REORIGIN(c1, s1, xx->angle, xx->orig);
REORIGIN(c2, s2, xx->angle, xx->orig);
cAngle = FindAngle(c1, c2);
int pn = dto[othPath].n;
int qn = dto[secPath].n;
// Tie length adjust
magic = 1 / cos(0.5 * D2R(dAngle));
// Extra ties length adjust
double magic2 = 1.0 / cos(0.5 * D2R(dAngle));
// Draw right half
len = FindDistance(dtod.midPt, c2);
cnt = (int)floor(len / dtod.td.spacing + 0.5);
if (cnt <= 0) {
return;
}
DIST_T dx = len / cnt;
p0 = q0 = 0;
DIST_T dx2 = dx / 2;
DIST_T px = len + dx2;
DIST_T lenx = 0;
while (p0 < pn && px > dto[othPath].base[p0 + 1].x) { p0++; }
while (q0 < qn && px > dto[secPath].base[q0 + 1].x) { q0++; }
while (p0 < pn && q0 < qn) {
if (px > dto[othPath].base[p0 + 1].x) { p0++; }
if (px > dto[secPath].base[q0 + 1].x) { q0++; }
if (p0 >= pn || q0 >= qn) {
break;
}
// Dont use baseLast, as base coOrds have been rotated
if ((px + dx >= dto[othPath].base[pn - 1].x)
|| (px + dx >= dto[secPath].base[qn - 1].x)) {
break;
}
DIST_T dy1 = dto[othPath].base[p0].y + (px - dto[othPath].base[p0].x) *
dto[othPath].dy[p0];
DIST_T dy2 = dto[secPath].base[q0].y + (px - dto[secPath].base[q0].x) *
dto[secPath].dy[q0];
tdlen = (dtod.td.length + fabs(dy1) + fabs(dy2)) * magic;
if(tdlen > tdmax) {
if(dAngle >= 30) {
DIST_T dy = (dy1 + dy2) / 2;
Translate(&pos,dtod.midPt,cAngle,px - len);
Translate(&pos,pos,(cAngle - 90.0),dy);
DrawTie(d,pos,cAngle,tdlen - dtod.td.length * magic,tdwid,color,
tieDrawMode == TIEDRAWMODE_SOLID);
lenx += dx2 * magic2;
}
break;
}
DIST_T dy = (dy1 + dy2) / 2;
Translate(&pos, dtod.midPt, cAngle, px - len);
Translate(&pos, pos, (cAngle - 90.0), dy);
DrawTie(d, pos, cAngle, tdlen, tdwid, color, tieDrawMode == TIEDRAWMODE_SOLID);
px += dx;
lenx += dx;
}
p1 = dtod.midPt;
p2 = dto[strPath].ptsLast;
DIST_T lenr = FindDistance(p1, p2) - lenx * magic2;
a0 = dto[strPath].angle;
if (lenr > dx) {
Translate(&pos, p2, a0, -lenr);
DrawStraightTies(d, dtod.td, pos, p2, color);
} else {
Translate(&pos, p2, a0, -dx2);
DrawTie(d, pos, a0, dtod.td.length, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
}
// p1 = dtod.midPt;
p2 = dto[str2Path].ptsLast;
lenr = FindDistance(p1, p2) - lenx * magic2;
a0 = dto[str2Path].angle;
if (lenr > dx) {
Translate(&pos, p2, a0, -lenr);
DrawStraightTies(d, dtod.td, pos, p2, color);
} else {
Translate(&pos, p2, a0, -dx2);
DrawTie(d, pos, a0, dtod.td.length, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
}
// Draw left half
// Change the straight path used
if (dtod.toType == DTO_SSLIP) {
othPath = str2Path;
}
len = FindDistance(c1, dtod.midPt);
cnt = (int)floor(len / dtod.td.spacing + 0.5);
if (cnt <= 0) {
return;
}
p0 = q0 = 0;
tdlen = dtod.td.length;
dx = len / cnt;
dx2 = dx / 2;
px = len - dx2;
lenx = 0;
while (p0 < pn && px > dto[othPath].base[p0 + 1].x) { p0++; }
while (q0 < qn && px > dto[secPath].base[q0 + 1].x) { q0++; }
while (p0 >= 0 && q0 >= 0) {
if (px < dto[othPath].base[p0].x) { p0--; }
if (px < dto[secPath].base[q0].x) { q0--; }
if (p0 < 0 || q0 < 0) {
break;
}
if ((px - dx < dto[othPath].base[0].x)
|| (px - dx < dto[secPath].base[0].x)) {
break;
}
DIST_T dy1 = dto[othPath].base[p0].y + (px - dto[othPath].base[p0].x) *
dto[othPath].dy[p0];
DIST_T dy2 = dto[secPath].base[q0].y + (px - dto[secPath].base[q0].x) *
dto[secPath].dy[q0];
tdlen = (dtod.td.length + fabs(dy1) + fabs(dy2)) * magic;
if(tdlen > tdmax) {
if(dAngle >= 30) {
DIST_T dy = (dy1 + dy2) / 2;
Translate(&pos,dtod.midPt,cAngle,px - len);
Translate(&pos,pos,(cAngle - 90.0),dy);
DrawTie(d,pos,cAngle,tdlen - dtod.td.length * magic,tdwid,color,
tieDrawMode == TIEDRAWMODE_SOLID);
lenx += dx2 * magic2;
}
break;
}
DIST_T dy = (dy1 + dy2) / 2;
Translate(&pos, dtod.midPt, cAngle, px - len);
Translate(&pos, pos, (cAngle - 90.0), dy);
DrawTie(d, pos, cAngle, tdlen, tdwid, color, tieDrawMode == TIEDRAWMODE_SOLID);
px -= dx;
lenx += dx;
}
p1 = dto[strPath].pts[0];
p2 = dtod.midPt;
a0 = dto[strPath].angle;
lenr = FindDistance(p1, p2) - lenx * magic2;
if (lenr > dx) {
Translate(&pos, p1, a0, lenr);
DrawStraightTies(d, dtod.td, p1, pos, color);
} else {
Translate(&pos, p1, a0, dx2);
DrawTie(d, pos, a0, dtod.td.length, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
}
p1 = dto[str2Path].pts[0];
// p2 = dtod.midPt;
a0 = dto[str2Path].angle;
lenr = FindDistance(p1, p2) - lenx * magic2;
if (lenr > dx) {
Translate(&pos, p1, a0, lenr);
DrawStraightTies(d, dtod.td, p1, pos, color);
} else {
Translate(&pos, p1, a0, dx2);
DrawTie(d, pos, a0, dtod.td.length, tdwid, color,
tieDrawMode == TIEDRAWMODE_SOLID);
}
}
/**
* Draw Crossover (Two Origin) Turnout Bridge and Ties. Uses the static dto and dtod structures.
*
* \param d The drawing object
* \param scaleInx The layout/track scale index
* \param color The tie color. If black the color is read from the global tieColor.
*/
static void DrawCrossTurnout(
drawCmd_p d,
SCALEINX_T scaleInx,
BOOL_T omitTies,
wDrawColor color)
{
DIST_T len, dx;
coOrd pos;
int cnt;
ANGLE_T angle;
if (color == wDrawColorBlack) {
color = tieColor;
}
// struct extraDataCompound_t* xx = dtod.xx;
DrawDtoInit();
// draw the points
#ifdef DTO_DEBUG
if (DTO_DEBUG == DTO_LCROSS) { DrawDtoLayout(d, scaleInx); }
#endif
int strPath = dtod.strPath, str2Path = dtod.str2Path;
// Bad assumption
int othPath = 2, secPath = 2;
if (dtod.pathCnt == 4) { secPath = 3; }
dto[strPath].angle = FindAngle(dto[strPath].pts[0], dto[strPath].ptsLast);
dto[str2Path].angle = FindAngle(dto[str2Path].pts[0], dto[str2Path].ptsLast);
if(dtod.bridge) {
DrawCrossFill(d,0,strPath,str2Path);
} else if(dtod.roadbed) {
DrawCrossFill(d,1,strPath,str2Path);
}
if (omitTies) {
return;
}
coOrd s1, s2, t1;
// coOrd t2, p1, p2, q1, q2;
int s0, t0, p0, q0;
int sn = dto[strPath].n;
int tn = dto[str2Path].n;
int pn = dto[othPath].n;
int qn = dto[secPath].n;
s1 = dto[strPath].pts[0];
s2 = dto[strPath].ptsLast;
t1 = dto[str2Path].pts[0];
// t2 = dto[str2Path].ptsLast;
angle = dto[strPath].angle;
// p1 = dto[othPath].base[0];
// p2 = dto[othPath].baseLast;
// q1 = dto[secPath].base[0];
// q2 = dto[secPath].baseLast;
len = FindDistance(s1, s2);
angle = dto[strPath].angle;
cnt = (int)floor(len / dtod.td.spacing + 0.5);
if (cnt > 0) {
DIST_T px = 0;
DIST_T dy, dy1, dy2;
int cflag = 0;
dy = dto[str2Path].base[0].y - dto[strPath].base[0].y;
dx = len / cnt;
s0 = t0 = p0 = q0 = 0;
DIST_T tdlen = dtod.td.length;
DIST_T tdwid = dtod.td.width;
DIST_T dlenx = dx / 2;
DIST_T px1 = len / 2 - dlenx * 5,
px2 = len / 2 + dlenx * 4;
for (px = dlenx; cnt; cnt--, px += dx) {
if (px >= dto[strPath].base[s0 + 1].x) { s0++; }
if (px >= dto[str2Path].base[t0 + 1].x) { t0++; }
if (px >= dto[othPath].base[p0 + 1].x) { p0++; }
if (px >= dto[secPath].base[q0 + 1].x) { q0++; }
if (s0 >= sn || t0 >= tn || p0 >= pn || q0 >= qn) {
break;
}
if ((px >= dto[strPath].baseLast.x)
|| (px >= dto[str2Path].baseLast.x)) {
break;
}
dy1 = dy2 = 0;
cflag = 0;
if (px < px1) {
switch (dtod.toType) {
case DTO_DCROSS:
dy1 = dto[othPath].base[p0].y + (px - dto[othPath].base[p0].x) *
dto[othPath].dy[p0];
dy2 = dy - dto[secPath].base[q0].y - (px - dto[secPath].base[q0].x) *
dto[secPath].dy[q0];
break;
case DTO_LCROSS:
dy1 = dto[othPath].base[p0].y + (px - dto[othPath].base[p0].x) *
dto[othPath].dy[p0];
dy2 = 0;
break;
case DTO_RCROSS:
dy1 = 0;
dy2 = dy - dto[secPath].base[q0].y - (px - dto[secPath].base[q0].x) *
dto[secPath].dy[q0];
break;
default:
break;
}
} else if (px < px2) {
dy1 = (dto[str2Path].base[s0].y - dto[strPath].base[t0].y);
dy2 = 0;
cflag = 1;
} else {
switch (dtod.toType) {
case DTO_DCROSS:
dy1 = dto[secPath].base[q0].y + (px - dto[secPath].base[q0].x) *
dto[secPath].dy[q0];
dy2 = dy - dto[othPath].base[p0].y - (px - dto[othPath].base[p0].x) *
dto[othPath].dy[p0];
break;
case DTO_LCROSS:
dy1 = 0;
dy2 = dy - dto[secPath].base[q0].y - (px - dto[secPath].base[q0].x) *
dto[secPath].dy[q0];
break;
case DTO_RCROSS:
dy1 = dto[othPath].base[p0].y + (px - dto[othPath].base[p0].x) *
dto[othPath].dy[p0];
dy2 = 0;
break;
default:
break;
}
}
if (fabs(dy1) + fabs(dy2) >= dy) {
dy1 = (dto[str2Path].base[s0].y - dto[strPath].base[t0].y);
dy2 = 0;
cflag = 1;
}
tdlen = dtod.td.length + fabs(dy1);
Translate(&pos, s1, angle, px);
Translate(&pos, pos, (angle - 90.0), dy1 / 2);
DrawTie(d, pos, angle, tdlen, tdwid, color, tieDrawMode == TIEDRAWMODE_SOLID);
if (!cflag) {
tdlen = dtod.td.length + fabs(dy2);
Translate(&pos, t1, angle, px);
Translate(&pos, pos, (angle - 90.0), -dy2 / 2);
DrawTie(d, pos, angle, tdlen, tdwid, color, tieDrawMode == TIEDRAWMODE_SOLID);
}
}
return;
// Draw remaining ties, if any
// Currently by definition, there won't be any
/*
if (px + dx < dto[strPath].baseLast.x) {
p1 = dto[strPath].pts[p0];
p2 = dto[strPath].ptsLast;
angle = FindAngle(p1, p2);
a0 = FindAngle(dto[strPath].base[p0], dto[strPath].baseLast);
DIST_T lenr = (dto[strPath].baseLast.x - px + dlenx) / cos(D2R(90.0 - a0));
Translate(&p1, p2, angle, -lenr);
DrawStraightTies(d, dtod.td, p1, p2, color);
}
else {
p1 = dto[strPath].pts[pn - 2];
a0 = FindAngle(p1, p2);
Translate(&pos, p2, a0, -dx / 2);
DrawTie(d, pos, a0, td->length, tdwid, color, tieDrawMode == TIEDRAWMODE_SOLID);
}
if (px + dx < dto[str2Path].baseLast.x) {
q1 = dto[str2Path].pts[q0];
q2 = dto[str2Path].ptsLast;
angle = FindAngle(q1, q2);
a0 = FindAngle(dto[str2Path].base[q0], dto[str2Path].baseLast);
DIST_T lenr = (dto[str2Path].baseLast.x - px + dlenx) / cos(D2R(90.0 - a0));
Translate(&q1, q2, angle, -lenr);
DrawStraightTies(d, dtod.td, q1, q2, color);
}
else {
q1 = dto[str2Path].pts[qn - 2];
a0 = FindAngle(q1, q2);
Translate(&pos, q2, a0, -dx / 2);
DrawTie(d, pos, a0, td->length, tdwid, color, tieDrawMode == TIEDRAWMODE_SOLID);
}
*/
}
}
/**
* Draw all turnout components: ties, rail, roadbed, etc.
*
* The turnout is checked to see if the enhanced methods can be used.
* If so the ties are drawn and the TB_NOTIES bit is set so that the
* rails and such are drawn on top of the ties. Similarly the bridge
* and roadbed bits are cleared so the enhanced method can be used.
* Those bits are restored to the previous state before return.
*
* \param trk Pointer to the track object
* \param d The drawing object
* \param color The turnout color.
*/
EXPORT void DrawTurnout(
track_p trk,
drawCmd_p d,
wDrawColor color)
{
struct extraDataCompound_t* xx = GET_EXTRA_DATA(trk, T_TURNOUT,
extraDataCompound_t);
wIndex_t i;
long widthOptions = 0;
SCALEINX_T scaleInx = GetTrkScale(trk);
BOOL_T omitTies = !DoDrawTies(d, trk) || !DrawTwoRails(d,1)
|| ((d->options & DC_SIMPLE) != 0); // || (scaleInx == 0);
widthOptions = DTS_LEFT | DTS_RIGHT;
// Save these values
int noTies = GetTrkNoTies(trk);
int bridge = GetTrkBridge(trk);
int roadbed = GetTrkRoadbed(trk);
long skip = 0;
/** @prefs [Preference] NormalTurnoutDraw=1 to skip enhanced drawing methods */
wPrefGetInteger("Preference", "NormalTurnoutDraw", (long *) &skip, 0);
int pathCnt = (skip == 0 ? GetTurnoutPaths(trk, xx) : 0);
if ( (pathCnt > 1) && (pathCnt <= DTO_DIM)
&& ( GetTrkEndPtCnt( trk ) <= 4)
&& (xx->special == TOnormal) ) {
dtod.bridge = bridge;
dtod.roadbed = roadbed;
// int strPath = -1;
GetTurnoutType();
if (dtod.toType != DTO_INVALID) {
switch (dtod.toType) {
case DTO_NORMAL:
case DTO_THREE:
case DTO_WYE:
DrawNormalTurnout(d, scaleInx, omitTies, color);
break;
case DTO_CURVED:
DrawCurvedTurnout(d, scaleInx, omitTies, color);
break;
case DTO_XING:
case DTO_XNG9:
case DTO_SSLIP:
case DTO_DSLIP:
DrawXingTurnout(d, scaleInx, omitTies, color);
break;
case DTO_LCROSS:
case DTO_RCROSS:
case DTO_DCROSS:
DrawCrossTurnout(d, scaleInx, omitTies, color);
break;
default:
break;
}
// Ignore these settings
SetTrkNoTies(trk, 1);
ClrTrkBits( trk,TB_BRIDGE );
ClrTrkBits(trk, TB_ROADBED);
}
}
// Begin standard DrawTurnout code to draw rails or centerline
// no curve center for turnouts, leave centerline for sectional curved
long opts = widthOptions | (xx->segCnt > 1 ? DTS_NOCENTER : 0);
DrawSegsO(d, trk, xx->orig, xx->angle, xx->segs, xx->segCnt, GetTrkGauge(trk),
color, opts);
for (i = 0; i < GetTrkEndPtCnt(trk); i++) {
DrawEndPt(d, trk, i, color);
}
if ((d->options & DC_SIMPLE) == 0 &&
(labelWhen == 2 || (labelWhen == 1 && (d->options & DC_PRINT))) &&
labelScale >= d->scale &&
(GetTrkBits(trk) & TB_HIDEDESC) == 0) {
DrawCompoundDescription(trk, d, color);
if (!xx->handlaid) {
LabelLengths(d, trk, color);
}
}
if (roadbedWidth > GetTrkGauge(trk) &&
DrawTwoRails( d, 1 ) &&
( (d->options & DC_PRINT) || roadbedOnScreen ) ) {
DrawTurnoutRoadbed(d, color, xx->orig, xx->angle, xx->segs, xx->segCnt);
}
// Restore these settings
if (noTies == 0) { ClrTrkBits(trk, TB_NOTIES); }
if (bridge) { SetTrkBits(trk, TB_BRIDGE); }
if (roadbed) { SetTrkBits(trk, TB_ROADBED); }
}