0

I am using Nate Robins' GLUT for Win 32. I have been using VS2015 and VS2010 on alternate systems for development. I've created a simulation of Dijkestra's on 5 nodes and the final output is the shortest path from the source node to the destination node printed in red dotted lines.

However, after a few changes the code simply wouldn't print the dotted lines on VS2015.

The same code works flawlessly on VS2010.

Screenshots

Visual Studio 2015 VS15

Visual Studio 2010 VS10

Code :-

void dijkstra(int s) {
    int i, k, mini;
    int visited[GRAPHSIZE];

    for (i = 1; i <= n; ++i) {
        d[i] = INFINITY;
        prev[i] = -1;
        visited[i] = 0;
        dummypath[i] = -1;
    }

    d[s] = 0;

    for (k = 1; k <= n; ++k) {
        mini = -1;
        for (i = 1; i <= n; ++i)
            if (!visited[i] && ((mini == -1) || (d[i] < d[mini])))
                mini = i;

        visited[mini] = 1;

        for (i = 1; i <= n; ++i)
            if (dist[mini][i]) {
                if (d[mini] + dist[mini][i] < d[i]) {
                    d[i] = d[mini] + dist[mini][i];
                    prev[i] = mini;
                }
            }
    }
}

void callPath(int a, int b) {

    std::cout << "Source :" << a << std::endl << "Dest :" << b << std::endl;
    int i, j, k;
    int u, v, w, dest, src;
    for (i = 0;i<GRAPHSIZE;i++) {
        getPath[i] = '\0';
        path[i] = '\0';

    }
    src = a;
    dest = b;

    dijkstra(src);

    destpath(dest);

    k = 0;
    std::cout << "Path" << std::endl;
    while (path[k] != '\0') {
        getPath[k] = path[k];
        std::cout << getPath[k] << std::endl;
        k++;
    }
}

void display4() {

    if (a == b) {
        if (a == 1) {
            getFinalCube1();
            glColor3f(0.0, 0.0, 1.0);
            drawString(10, 295, 0, "Source");
            drawString(10, 210, 0, "Destination");
            glFlush();
        }
        else if (a == 2) {
            getFinalCube2();
            glColor3f(0.0, 0.0, 1.0);
            drawString(110, 460, 0, "Source");
            drawString(110, 375, 0, "Destination");
            glFlush();
        }
        else if (a == 3) {
            getFinalCube3();
            glColor3f(0.0, 0.0, 1.0);
            drawString(285, 460, 0, "Source");
            drawString(285, 375, 0, "Destination");
            glFlush();
        }
        else if (a == 4) {
            getFinalCube4();
            glColor3f(0.0, 0.0, 1.0);
            drawString(110, 130, 0, "Source");
            drawString(110, 45, 0, "Destination");
            glFlush();
        }
        else {
            getFinalCube5();
            glColor3f(0.0, 0.0, 1.0);
            drawString(285, 130, 0, "Source");
            drawString(285, 45, 0, "Destination");
            glFlush();
        }
        glFlush();
    }
    else {
        glColor3f(0.0, 0.0, 1.0);
        if (a == 1)
            drawString(10, 295, 0, "Source");
        else if (a == 2)
            drawString(110, 460, 0, "Source");
        else if (a == 3)
            drawString(285, 460, 0, "Source");
        else if (a == 4)
            drawString(110, 130, 0, "Source");
        else if (a == 5)
            drawString(285, 130, 0, "Source");

        if (b == 1)
            drawString(10, 210, 0, "Destination");
        else if (b == 2)
            drawString(110, 375, 0, "Destination");
        else if (b == 3)
            drawString(285, 375, 0, "Destination");
        else if (b == 4)
            drawString(110, 45, 0, "Destination");
        else if (b == 5)
            drawString(285, 45, 0, "Destination");

        i = 0;
        while (getPath[i + 1] != '\0') {
            if (getPath[i] == 1) {
                getFinalCube1();
                glFlush();
                if (getPath[i + 1] == 2) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 60) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(110 + x, 290 + y, 0);
                        glVertex3f(125 + x, 307.5 + y, 0);
                        glVertex3f(130 + x, 302.5 + y, 0);
                        glVertex3f(115 + x, 285 + y, 0);
                        glVertex3f(110 + x, 290 + y, 0);
                        y = y + 33;
                        x = x + 25;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 100; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube2();
                    glFlush();
                }
                else if (getPath[i + 1] == 3) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 31) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(112.5 + x, 250 + y, 0);
                        glVertex3f(135 + x, 265 + y, 0);
                        glVertex3f(137.5 + x, 260 + y, 0);
                        glVertex3f(115 + x, 245 + y, 0);
                        glVertex3f(112.5 + x, 250 + y, 0);
                        y = y + 25;
                        x = x + 48;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 100; k++) {
                            delay();
                        }
                        glFlush();
                    }

                    getFinalCube3();
                    glFlush();
                }
                else if (getPath[i + 1] == 4) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 60) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(65 + x, 220 + y, 0);
                        glVertex3f(80 + x, 200 + y, 0);
                        glVertex3f(75 + x, 195 + y, 0);
                        glVertex3f(60 + x, 215 + y, 0);
                        glVertex3f(65 + x, 220 + y, 0);
                        y = y - 33;
                        x = x + 25;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube4();
                    glFlush();
                }
                else {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 40) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(95 + x, 210 + y, 0);
                        glVertex3f(117.5 + x, 197.5 + y, 0);
                        glVertex3f(115 + x, 192.5 + y, 0);
                        glVertex3f(92.5 + x, 205 + y, 0);
                        glVertex3f(95 + x, 210 + y, 0);
                        y = y - 32;
                        x = x + 56;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }

                    getFinalCube5();
                    glFlush();
                }
                glFlush();
            }
            else if (getPath[i] == 2) {
                getFinalCube2();
                glFlush();
                if (getPath[i + 1] == 1) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 60) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(120 + x, 375 + y, 0);
                        glVertex3f(125 + x, 370 + y, 0);
                        glVertex3f(110 + x, 350 + y, 0);
                        glVertex3f(105 + x, 355 + y, 0);
                        glVertex3f(120 + x, 375 + y, 0);
                        y = y - 25;
                        x = x - 18;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 100; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube1();
                    glFlush();
                }
                else if (getPath[i + 1] == 3) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 50) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(212.5 + x, 445 + y, 0);
                        glVertex3f(237.5 + x, 445 + y, 0);
                        glVertex3f(237.5 + x, 438 + y, 0);
                        glVertex3f(212.5 + x, 438 + y, 0);
                        glVertex3f(212.5 + x, 445 + y, 0);
                        y = y;
                        x = x + 30;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube3();
                    glFlush();
                }
                else if (getPath[i + 1] == 4) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 35) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(135 + x, 380 + y, 0);
                        glVertex3f(137.5 + x, 355 + y, 0);
                        glVertex3f(142.5 + x, 359 + y, 0);
                        glVertex3f(140 + x, 383.5 + y, 0);
                        glVertex3f(135 + x, 380 + y, 0);
                        y = y - 70;
                        x = x + 5;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube4();

                    glFlush();
                }
                else {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 31) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(182.5 + x, 367.5 + y, 0);
                        glVertex3f(195 + x, 345 + y, 0);
                        glVertex3f(190 + x, 342.5 + y, 0);
                        glVertex3f(177.5 + x, 365 + y, 0);
                        glVertex3f(182.5 + x, 367.5 + y, 0);
                        y = y - 66;
                        x = x + 37;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 100; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube5();
                    glFlush();
                }
                glFlush();
            }
            else if (getPath[i] == 3) {
                getFinalCube3();
                glFlush();
                if (getPath[i + 1] == 1) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 31) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(297.5 + x, 382.5 + y, 0);
                        glVertex3f(275 + x, 372.5 + y, 0);
                        glVertex3f(277.5 + x, 367.5 + y, 0);
                        glVertex3f(300 + x, 377.5 + y, 0);
                        glVertex3f(297.5 + x, 382.5 + y, 0);
                        y = y - 25;
                        x = x - 50;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 100; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube1();
                    glFlush();
                }
                else if (getPath[i + 1] == 2) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 60) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(290 + x, 385 + y, 0);
                        glVertex3f(287.5 + x, 380 + y, 0);
                        glVertex3f(265 + x, 387.5 + y, 0);
                        glVertex3f(267.5 + x, 392.5 + y, 0);
                        glVertex3f(290 + x, 385 + y, 0);
                        y = y + 6.25;
                        x = x - 30;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 100; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube2();
                    glFlush();
                }
                else if (getPath[i + 1] == 4) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 31) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(295 + x, 372.5 + y, 0);
                        glVertex3f(282.5 + x, 350 + y, 0);
                        glVertex3f(287.5 + x, 347.5 + y, 0);
                        glVertex3f(300 + x, 370 + y, 0);
                        glVertex3f(295 + x, 372.5 + y, 0);
                        y = y - 66.25;
                        x = x - 37.5;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 100; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube4();
                    glFlush();
                }
                else {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 35) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(310 + x, 385 + y, 0);
                        glVertex3f(313 + x, 360 + y, 0);
                        glVertex3f(317.5 + x, 362.5 + y, 0);
                        glVertex3f(315 + x, 387.5 + y, 0);
                        glVertex3f(310 + x, 385 + y, 0);
                        y = y - 70;
                        x = x + 5;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube5();

                    glFlush();
                }
                glFlush();
            }
            else if (getPath[i] == 4) {
                getFinalCube4();
                glFlush();
                if (getPath[i + 1] == 1) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 45) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(127.5 + x, 115 + y, 0);
                        glVertex3f(112.5 + x, 135 + y, 0);
                        glVertex3f(107.5 + x, 132.5 + y, 0);
                        glVertex3f(122.5 + x, 112.5 + y, 0);
                        glVertex3f(127.5 + x, 115 + y, 0);
                        y = y + 31.25;
                        x = x - 25;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube1();
                    glFlush();
                }
                else if (getPath[i + 1] == 2) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 35) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(210 + x, 125 + y, 0);
                        glVertex3f(207.5 + x, 155 + y, 0);
                        glVertex3f(212.5 + x, 157.5 + y, 0);
                        glVertex3f(215 + x, 127.5 + y, 0);
                        glVertex3f(210 + x, 125 + y, 0);
                        y = y + 70;
                        x = x - 5;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube2();
                    glFlush();
                }
                else if (getPath[i + 1] == 3) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 22) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(210 + x, 125 + y, 0);
                        glVertex3f(222.5 + x, 145 + y, 0);
                        glVertex3f(226 + x, 138 + y, 0);
                        glVertex3f(215 + x, 120 + y, 0);
                        glVertex3f(210 + x, 125 + y, 0);
                        y = y + 45;
                        x = x + 25;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }

                    getFinalCube3();
                    glFlush();
                }
                else {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 50) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(180 + x, 50 + y, 0);
                        glVertex3f(205 + x, 50 + y, 0);
                        glVertex3f(205 + x, 42.5 + y, 0);
                        glVertex3f(180 + x, 42.5 + y, 0);
                        glVertex3f(180 + x, 50 + y, 0);
                        y = y;
                        x = x + 40;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube5();
                    glFlush();
                }
                glFlush();
            }
            else {
                getFinalCube5();
                glFlush();
                if (getPath[i + 1] == 1) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 30) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(315 + x, 120 + y, 0);
                        glVertex3f(287.5 + x, 132.5 + y, 0);
                        glVertex3f(282.5 + x, 127.5 + y, 0);
                        glVertex3f(310 + x, 115 + y, 0);
                        glVertex3f(315 + x, 120 + y, 0);
                        y = y + 25;
                        x = x - 45;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }

                    getFinalCube1();
                    glFlush();
                }
                else if (getPath[i + 1] == 2) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 30) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(362.5 + x, 130 + y, 0);
                        glVertex3f(350 + x, 150 + y, 0);
                        glVertex3f(345 + x, 147.5 + y, 0);
                        glVertex3f(357.5 + x, 127.5 + y, 0);
                        glVertex3f(362.5 + x, 130 + y, 0);
                        y = y + 60;
                        x = x - 35;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }

                    getFinalCube2();
                    glFlush();
                }
                else if (getPath[i + 1] == 3) {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 35) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(385 + x, 125 + y, 0);
                        glVertex3f(382.5 + x, 155 + y, 0);
                        glVertex3f(387.5 + x, 157.5 + y, 0);
                        glVertex3f(390 + x, 127.5 + y, 0);
                        glVertex3f(385 + x, 125 + y, 0);
                        y = y + 70;
                        x = x - 5;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }
                    getFinalCube3();
                    glFlush();
                }
                else {
                    x = 0;
                    y = 0;
                    x = m[i][i + 1] * y;
                    for (j = 0; j < 125; j = j + 60) {
                        glBegin(GL_POLYGON);
                        glColor3f(1.0, 0.0, 0.0);
                        glVertex3f(295 + x, 95 + y, 0);
                        glVertex3f(270 + x, 90 + y, 0);
                        glVertex3f(272.5 + x, 85 + y, 0);
                        glVertex3f(297.5 + x, 90 + y, 0);
                        glVertex3f(295 + x, 95 + y, 0);
                        y = y - 5;
                        x = x - 35;

                        glFlush();
                        glEnd();
                        for (k = 0; k <= 300; k++) {
                            delay();
                        }
                        glFlush();
                    }

                    getFinalCube4();
                    glFlush();
                }
                glFlush();
            }
            i++;
            glFlush();
        }
    }
    glFlush();
}

The Complete code is available here.

I really don't understand why the code isn't working on VS2015 but works fine with VS2010. Any help is welcome as I use VS2010 on my desktop and hence carrying it everywhere isn't really possible.

Rabbid76
  • 202,892
  • 27
  • 131
  • 174
agupta
  • 175
  • 2
  • 14
  • Also the boxes did change color (yellow -> green). – BDL May 11 '18 at 08:55
  • Also: Do you execute both versions on the same machine? Otherwise it could also be a problem with the GPU/OS configuration/whatever. It would also be good to strip down the code to the relevant parts. It is very long at the moment which makes it hard to identify where the dashed lines are drawn. – BDL May 11 '18 at 08:58
  • Yes yesterday I installed VS2010 on the same machine...I don't why the boxes aren't changing color in VS2015. – agupta May 11 '18 at 09:32
  • I am running the same code on both VS versions. Why would the result vary depending upon the IDE Versions... – agupta May 11 '18 at 09:35
  • The `glFinalCube` functions 1-5 use a green color `glColor3f(0.0, 1.0, 0.0);` So I don't think this is a compiler issue. Also there is a `glColor3f(0.0, 0.0, 0.0)` that resets the color (why you may not see the connection line). After that the `drawString` function is called. Here may be the problem somewhere. – YesThatIsMyName May 11 '18 at 11:15
  • @YesThatIsMyName (funny name btw) I didn't understand which `glColor3f()` or `glFinalCube()` you are referring to with there being so many of them(please give me the function name/Line no. the github link to the complete code is given in the question). Secondly, the code works.The same code runs flawlessly on VS2010, I don't know what causes it to bug out in VS2015. – agupta May 13 '18 at 04:33
  • @CozImBat Hi, I can compile your code with g++. I don't know what modifications you have done, but the code itself is very buggy on my linux system. I was able to get the first (all yellow) and the second pic (green with red dotted line). I am afraid you will have to figure it out yourself. There are several unused variables ... the code itself is very unclean. – YesThatIsMyName May 14 '18 at 07:17

0 Answers0