Изобразить сечение 3х-мерной фигуры треугольником

#include <graphics.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
 
#define Pi 3.14159265
 
#define SLEEPTIME 100
#define PRISMHEIGHT 200
#define MULT 30
#define LE 30
#define PRSIDS 6
#define PRDOTS 8 
#define PREDGS 12
 
void InitMatr(float matr[3][3]);
void GetNewPrism(int pr[][3], float matr[3][3], int newPr[][2], int co);
void DrawModel(int pr[PRDOTS][2], int sides[8][4], int edges[PREDGS][4]);
void setVisibility(int sides[8][4], int newPr[PRDOTS][2]);
void GetNewTriangle(int pr[3][3], float matr[3][3], int newTr[3][3]);
void GetRotTriangle(int pr[3][3], float matr[3][3], int newTr[3][3]);
void DrawTriangle(int pr[3][3], int sides[1][4], int edges[3][4]);
void InitRotMatr(float matr[3][3], float a);
void cutt(int tr[3][3], int trEdges[3][4], int pr[PRDOTS][3], int sides[PRSIDS][4]);
int ymax = 4 * MULT;
int ymin = 0;
int xmax = 4 * MULT;
int xmin = 0;
int zmax = PRISMHEIGHT;
int zmin = 0;
 
int main(void)
{
    initwindow(900,790,"Lab");
    setfillstyle(1, BLACK);
    double sq3 = sqrt(2);
    int prSides[PRSIDS][4] = {
        { 0, 1, 2, 1 },
        { 5, 1, 0, 1 }, { 6, 2, 1, 1 }, { 7, 3, 2, 1 }, { 4, 0, 3, 1 },
        { 6, 5, 4, 1 } };
    int prEdges[PREDGS][4] = {
        { 0, 1, 0, 1 }, { 1, 2, 0, 2 }, { 2, 3, 0, 3 }, { 3, 0, 0, 4 },
        { 0, 4, 1, 4 }, { 1, 5, 1, 2 }, { 2, 6, 2, 3 }, { 3, 7, 3, 4 },
        { 4, 5, 5, 1 }, { 5, 6, 5, 2 }, { 6, 7, 5, 3 }, { 7, 4, 5, 4 },
    };
    int prism[PRDOTS][3] = {
        { 0, 0, 0 }, { MULT * 4, 0, 0 }, { 4 * MULT, 4 * MULT, 0 }, { 0, 4 * MULT, 0 },
        { 0, 0, PRISMHEIGHT }, { 4 * MULT, 0, PRISMHEIGHT }, { 4 * MULT, 4 * MULT, PRISMHEIGHT }, { 0, 4 * MULT, PRISMHEIGHT } };
 
    int trSides[1][4] = { { 0, 1, 2, 1 } };
    int trEdges[3][4] = { { 0, 1, 0, 0 }, { 1, 2, 0, 0 }, { 2, 0, 0, 0 } };
    int triangle[3][3] = {
        { -MULT * 2, 0, 0 },
        { MULT * 2, 0, 0 },
        { 0, MULT, MULT * 4 } };
    int newPrism[PRDOTS][2];
    int newTriangle[3][3];
    int cutTriangle[3][3];
    int rotatedTr[3][3];
 
    float R[3][3];
    float triangle_R[3][3];
 
    int i;
    int j = 0;
 
    for (j = 0, j = j % 360;; j += 5) {
 
        InitMatr(R);
        GetNewPrism(prism, R,newPrism, PRDOTS);
        setVisibility(prSides, newPrism);
        DrawModel(newPrism, prSides, prEdges);
 
        InitRotMatr(triangle_R, j*0.017);
        GetRotTriangle(triangle, triangle_R, rotatedTr);
        cutt(rotatedTr, trEdges, prism, prSides);
        Sleep(SLEEPTIME);
    }
 
    closegraph();
    return 0;
}
 
void GetNewPrism(int pr[][3], float matr[3][3], int newPr[][2], int co)
{
    int i, j, k;
    float newEl;
 
    for (i = 0; i < co; i++) {
        for (j = 0; j < 2; j++) {
            newEl = 0.0;
            for (k = 0; k < 3; k++)
                newEl += pr[i][k] * matr[k][j];
            newPr[i][j] = -(int)newEl + 330;
 
        }
    }
}
 
struct coord3D{
    int x, y, z;
};
struct coord2D{
    int x, y;
};
float determ(int matr[4][4], int i, int j, int k){
    return ((matr[1][i] * matr[2][j] * matr[3][k])
        + (matr[3][i] * matr[1][j] * matr[2][k])
        + (matr[2][i] * matr[3][j] * matr[1][k])
        - (matr[3][i] * matr[2][j] * matr[1][k])
        - (matr[1][i] * matr[3][j] * matr[2][k])
        - (matr[2][i] * matr[1][j] * matr[3][k]));
}
 
void findcross(
struct coord3D p, struct coord3D q,
    int matr[4][4],
struct coord3D *rez, struct coord3D *norm,
    float *lm){
 
    float r1, r2, r3, k1, k2, k3, k;
 
    k1 = determ(matr, 1, 2, 3);
    k2 = -determ(matr, 0, 2, 3);
    k3 = determ(matr, 0, 1, 3);
    k = -determ(matr, 0, 1, 2);
 
    (*norm).x = k1;
    (*norm).y = k2;
    (*norm).z = k3;
 
    r1 = q.x - p.x;
    r2 = q.y - p.y;
    r3 = q.z - p.z;
    *lm = -(k + k1*p.x + k2*p.y + k3*p.z) / (k1*r1 + k2*r2 + k3*r3);
    if (*lm <= 1 && *lm > 0){
        (*rez).x = (p.x + (*lm)*r1);
        (*rez).y = (p.y + (*lm)*r2);
        (*rez).z = (p.z + (*lm)*r3);
    }
    else{
        (*rez).x = 0;
        (*rez).y = 0;
        (*rez).z = 0;
        *lm = -1;
    }
}
 
int findin(int pr[][3], int sides[][4], struct coord3D rez){
    int ed,flag = 1;
    float k1, k2, k3,k,sum;
    struct coord3D n, tmp;
    for (ed = 0; ed < 6; ed++){
        int matr[4][4] = {
            { 0, 0, 0, 1 },
            { pr[sides[ed][0]][0], pr[sides[ed][0]][1], pr[sides[ed][0]][2], 1 },
            { pr[sides[ed][1]][0], pr[sides[ed][1]][1], pr[sides[ed][1]][2], 1 },
            { pr[sides[ed][2]][0], pr[sides[ed][2]][1], pr[sides[ed][2]][2], 1 }
        };
        k1 = determ(matr, 1, 2, 3);
        k2 = -determ(matr, 0, 2, 3);
        k3 = determ(matr, 0, 1, 3);
        printf("\n %f ", k1);
        printf("\n %f ", k2);
        printf("\n %f \n", k3);
            sum = rez.x*k1 + rez.y*k2 + rez.z*k3;
        printf("\n %f 4", sum);
        if (sum<=0){
            flag = 0;
            Sleep(50000);
        }
        if (sum>0){
            flag = 0;
            break;
        }
    }
    return flag;
}
 
void cutt(int tr[3][3], int trEdges[3][4], int pr[PRDOTS][3], int sides[PRSIDS][4])
{
    float R[3][3];
    int coordin[2][3];
    int coordout[2][2];
    int j, i;
    int ed = 1, id = 1;
    int flag_find_dot, flag_find_sec;
    for (i = 0; i < 3; i++){
        float r1, r2, r3, k1, k2, k3, k, lm;
        struct coord3D p, q, rez,norm, s, e, tmp;
        p.x = tr[trEdges[i][0]][0];
        p.y = tr[trEdges[i][0]][1];
        p.z = tr[trEdges[i][0]][2];
 
        q.x = tr[trEdges[i][1]][0];
        q.y = tr[trEdges[i][1]][1];
        q.z = tr[trEdges[i][1]][2];
 
        coordin[0][0] = q.x;
        coordin[0][1] = q.y;
        coordin[0][2] = q.z;
        coordin[1][0] = p.x;
        coordin[1][1] = p.y;
        coordin[1][2] = p.z;
        setcolor(BLUE);
        InitMatr(R);
        GetNewPrism(coordin, R, coordout, 2);
        line(coordout[0][0], coordout[0][1], coordout[1][0], coordout[1][1]);
 
 
        if ((p.y > ymin) && (q.y > ymin) &&
            (p.y < ymax) && (q.y < ymax) &&
            (p.x > xmin) && (q.x > xmin) &&
            (p.x < xmax) && (q.x < xmax) &&
            (p.z > zmin) && (q.z > zmin) &&
            (p.z < zmax) && (q.z < zmax)){
            s = p;
            e = q;
            flag_find_dot = -2;
        }
        else{
            for (ed = 0; ed < 6; ed++){
                flag_find_dot = -1;
                flag_find_sec = 0;
                int matr[4][4] = {
                    { 0, 0, 0, 1 },
                    { pr[sides[ed][0]][0], pr[sides[ed][0]][1], pr[sides[ed][0]][2], 1 },
                    { pr[sides[ed][1]][0], pr[sides[ed][1]][1], pr[sides[ed][1]][2], 1 },
                    { pr[sides[ed][2]][0], pr[sides[ed][2]][1], pr[sides[ed][2]][2], 1 }
                };
                findcross(p, q, matr, &rez,&norm, &lm);
 
                if (lm <= 1 && lm > 0){
                    tmp = rez;
                    flag_find_dot = ed;
                    if ((rez.y >= ymin) && (rez.y <= ymax) &&
                        (rez.x >= xmin) && (rez.x <= xmax) &&
                        (rez.z >= zmin) && (rez.z <= zmax))
                    for (id = 0; id < 6; id++){
                        if (id != flag_find_dot){
                            int matr[4][4] = {
                                { 0, 0, 0, 1 },
                                { pr[sides[id][0]][0], pr[sides[id][0]][1], pr[sides[id][0]][2], 1 },
                                { pr[sides[id][1]][0], pr[sides[id][1]][1], pr[sides[id][1]][2], 1 },
                                { pr[sides[id][2]][0], pr[sides[id][2]][1], pr[sides[id][2]][2], 1 }
                            };
                            findcross(p, q, matr, &rez,&norm, &lm);
 
                            if (lm <= 1 && lm > 0){
                                if ((rez.y >= ymin) && (rez.y <= ymax) &&
                                    (rez.x >= xmin) && (rez.x <= xmax) &&
                                    (rez.z >= zmin) && (rez.z <= zmax)){
 
                                    e = rez;
                                    s = tmp;
                                    flag_find_dot = ed;
                                    flag_find_sec = 1;
                                    break;
                                }
                            }
                        }
                    }
                    if (flag_find_sec){
                        break;
                    }
                    else{
                        rez = tmp;
                        if ((p.y > ymin) && (p.y < ymax) &&
                            (p.x > xmin) && (p.x < xmax) &&
                            (p.z > zmin) && (p.z < zmax)){
                            s = p;
                            e = rez;
                            if ((rez.y >= ymin) && (rez.y <= ymax) &&
                                (rez.x >= xmin) && (rez.x <= xmax) &&
                                (rez.z >= zmin) && (rez.z <= zmax)){
                                flag_find_dot = ed;
                                break;
                            }
                        }
                        else
                        if ((q.y >= ymin) && (q.y <= ymax) &&
                            (q.x >= xmin) && (q.x <= xmax) &&
                            (q.z >= zmin) && (q.z <= zmax)){
                            s = q;
                            e = rez;
                            if ((rez.y >= ymin) && (rez.y <= ymax) &&
                                (rez.x >= xmin) && (rez.x <= xmax) &&
                                (rez.z >= zmin) && (rez.z <= zmax)){
                                flag_find_dot = ed;
                                break;
                            }
                        }
                    }
                }
                else
                    flag_find_dot = -1;
            }
        }
        if (flag_find_dot != -1){
            coordin[0][0] = s.x;
            coordin[0][1] = s.y;
            coordin[0][2] = s.z;
            coordin[1][0] = e.x;
            coordin[1][1] = e.y;
            coordin[1][2] = e.z;
            setcolor(GREEN);
            InitMatr(R);
            GetNewPrism(coordin, R, coordout, 2);
            line(coordout[0][0], coordout[0][1], coordout[1][0], coordout[1][1]);
        }
    }
}
 
void InitRotMatr(float matr[3][3], float a)
{
    float sa, sb, ca, cb;
    sa = sin(a);
    ca = cos(a);
    matr[0][0] = ca;
    matr[0][1] = sa;
    matr[0][2] = 0.0;
    matr[1][0] = -sa;
    matr[1][1] = ca;
    matr[1][2] = 0.0;
    matr[2][0] = 0.0;
    matr[2][1] = 0.0;
    matr[2][2] = 1.0;
}
 
void GetRotTriangle(int pr[3][3], float matr[3][3], int newTr[3][3])
{
    int i, j, k;
    float newEl;
 
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3; j++) {
            newEl = 0.0;
            for (k = 0; k < 3; k++)
                newEl += (pr[i][k]) * matr[k][j];
            if (j == 0)
                newTr[i][j] = (int)newEl + MULT;
            else if (j == 1)
                newTr[i][j] = (int)newEl - MULT*0.5;
            else
                newTr[i][j] = (int)newEl + LE;
        }
    }
}
 
void GetNewTriangle(int pr[3][3], float matr[3][3], int newTr[3][3])
{
    int i, j, k;
    float newEl;
 
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 2; j++) {
            newEl = 0.0;
            for (k = 0; k < 3; k++)
                newEl += pr[i][k] * matr[k][j];
            newTr[i][j] = -(int)newEl + 330;
        }
    }
}
 
void DrawModel(int pr[PRDOTS][2], int sides[5][4], int edges[PREDGS][4])
{
     
    int i;
    setcolor(BLACK);
    bar(0, 0, 900, 700);
    for (i = 0; i < PREDGS; i++) {
        if (sides[edges[i][2]][3] != 0 || sides[edges[i][3]][3] != 0)
        {
            setcolor(WHITE);
            moveto(pr[edges[i][0]][0], pr[edges[i][0]][1]);
            lineto(pr[edges[i][1]][0], pr[edges[i][1]][1]);
        }
        else
        {
            // Nothing.
        }
    }
}
 
void setVisibility(int sides[8][4], int newPr[PRDOTS][2])
{
    int i, j;
    int ux, vx, uy, vy;
 
    for (i = 0; i < PRSIDS; i++) {
        ux = newPr[sides[i][1]][0] - newPr[sides[i][2]][0];
        vx = newPr[sides[i][0]][0] - newPr[sides[i][1]][0];
        uy = -newPr[sides[i][1]][1] + newPr[sides[i][2]][1];
        vy = -newPr[sides[i][0]][1] + newPr[sides[i][1]][1];
        j = ux * vy - uy * vx;
 
        if (j < 0)
            sides[i][3] = 0;
        else
            sides[i][3] = 1;
    }
}
 
void InitMatr(float matr[3][3])
{
    float sa, sb, ca, cb;
    sa = sqrt(2) / 2;
    ca = sqrt(2) / 2;
    sb = (-1)*sqrt(2) / 2;
    cb = (-1)*sqrt(2) / 2;
    matr[0][0] = cb*1.0;
    matr[0][1] = 1.0 *sa*sb;
    matr[0][2] = 0.0;
    matr[1][0] = 0.0;
    matr[1][1] = 1.0*ca;
    matr[1][2] = 0.0;
    matr[2][0] = 1.0*sb;
    matr[2][1] = (-1.0) * sb*sa;
    matr[2][2] = 0.0;
}