Странный артефакт в корявой собственноручно написанной 3D графике

#include <SFML/Graphics.hpp>
#include <Windows.h>
#include <iostream>
#include <time.h>
 
using namespace sf;
using namespace std;
 
class point
{
public:
    float x, y, z;
    point()
    {
        x = -1; y = -1; z = -1;
    }
    point(float X, float Y)
    {
        x = X; y = Y; z = -1;
    }
    point(float X, float Y, float Z)
    {
        x = X; y = Y; z = Z;
    }
    point(int X, int Y)
    {
        x = X; y = Y; z = -1;
    }
    point(int X, int Y, int Z)
    {
        x = X; y = Y; z = Z;
    }
    void get(point a)
    {
        x = a.x;
        y = a.y;
        z = a.z;
    }
    void get(float X, float Y, float Z)
    {
        x = X;
        y = Y;
        z = Z;
    }
    void get(int X, int Y, int Z)
    {
        x = X;
        y = Y;
        z = Z;
    }
};
 
struct polygone
{
public:
    point points[3];
    polygone()
    {
    }
    polygone(point a, point b, point c)
    {
        points[0].get(a);
        points[1].get(b);
        points[2].get(c);
    }
    void set(point a, point b, point c)
    {
        points[0].get(a);
        points[1].get(b);
        points[2].get(c);
    }
};
 
struct camera
{
public:
    point pos;
    float horangle, verangle;
    camera()
    {
        horangle = 0;
        verangle = 0;
    }
    camera(point a)
    {
        pos.get(a);
        horangle = 0;
        verangle = 0;
    }
    camera(float x, float y, float z)
    {
        pos.get(x, y, z);
        horangle = 0;
        verangle = 0;
    }
    camera(point a, float hora, float vera)
    {
        pos.get(a);
        horangle = hora;
        verangle = vera;
    }
    camera(float x, float y, float z, float hora, float vera)
    {
        pos.get(x, y, z);
        horangle = hora;
        verangle = vera;
    }
    camera(point a, int hora, int vera)
    {
        pos.get(a);
        horangle = hora;
        verangle = vera;
    }
    camera(float x, float y, float z, int hora, int vera)
    {
        pos.get(x, y, z);
        horangle = hora;
        verangle = vera;
    }
};
 
//Кстати esc не всегда выпускает из проги, юзай alt tab
//Всякие переменные
int sw = GetSystemMetrics(SM_CXSCREEN);
int sh = GetSystemMetrics(SM_CYSCREEN);
bool needreview = true;
bool* review;
bool* work;
const int hmpg = 12; //Когда что-то меняешь с полигонами, следи, чтобы это число соответствовало числу полигонов
const int optimiz = 0;
polygone pg[hmpg];
camera cm(point(25, 30, 0));
 
//Много функций для всякой тригонометрии
 
float dist(point a, point b)
{
    return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2) + pow(a.z - b.z, 2));
}
 
float lenght(point a)
{
    return sqrt(pow(a.x, 2) + pow(a.y, 2) + pow(a.z, 2));
}
 
float whatisangle(point a, point b)
{
    return (acos((a.x * b.x + a.y * b.y + a.z * b.z) / (lenght(a) * lenght(b)))) * 57.29578;
}
 
int whatisangle(point vec)
{
    float gippo = sqrt(vec.x * vec.x + vec.y * vec.y);
    float cosshit = abs(vec.x / gippo);
    float sinshit = abs(vec.y / gippo);
    int angle = 0;
    int fourth = 0;
    if (vec.x >= 0 && vec.y >= 0) fourth = 0;
    if (vec.x <= 0 && vec.y >= 0) fourth = 1;
    if (vec.x <= 0 && vec.y <= 0) fourth = 2;
    if (vec.x >= 0 && vec.y <= 0) fourth = 3;
    angle = asin(sinshit) * 57.29577951308232;
    angle = angle + 90 * fourth;
 
    if (vec.x == 0 && vec.y == 0) return 0; else return angle;
}
 
point pointmid(point a, point b)
{
    return point((a.x + b.x) / 2, (a.y + b.y) / 2, (a.z + b.z) / 2);
}
 
point rotatevec(point vec, int angle)
{
    point a;
    a.x = vec.x * cosf(angle * 0.0174533) - vec.y * sinf(angle * 0.0174533);
    a.y = vec.x * sinf(angle * 0.0174533) + vec.y * cosf(angle * 0.0174533);
    return a;
}
 
void domatrix(point& i, point& o, float m[4][4])
{
    o.x = i.x * m[0][0] + i.y * m[1][0] + i.z * m[2][0] + m[3][0];
    o.y = i.x * m[0][1] + i.y * m[1][1] + i.z * m[2][1] + m[3][1];
    o.z = i.x * m[0][2] + i.y * m[1][2] + i.z * m[2][2] + m[3][2];
    float w = i.x * m[0][3] + i.y * m[1][3] + i.z * m[2][3] + m[3][3];
    if (w != 0.0f)
    {
        o.x /= w; o.y /= w; o.z /= w;
    }
}
 
int main()
{
    //Эт кнопки смотреть, не важное
    while (false) for (int i = 0; i < 256; i++) if (GetAsyncKeyState(i)) { std::cout << "Pressed " << i << std::endl; Sleep(100); }
    //Задаем полигоны
    /**/
    //Тетраэдр
    /*
    pg[0].set(point(28, 28, -1), point(30, 30, 3), point(28, 32, -1));
    pg[1].set(point(28, 28, -1), point(30, 30, 3), point(32, 30, -1));
    pg[2].set(point(32, 30, -1), point(30, 30, 3), point(28, 32, -1));
    */
    pg[0].set(point(0, 0, 0), point(0, 1, 0), point(1, 1, 0));
    pg[1].set(point(0, 0, 0), point(1, 1, 0), point(1, 0, 0));
 
    pg[2].set(point(1, 0, 0), point(1, 1, 0), point(1, 1, 1));
    pg[3].set(point(1, 0, 0), point(1, 1, 1), point(1, 0, 1));
 
    pg[4].set(point(1, 0, 1), point(1, 1, 1), point(0, 1, 1));
    pg[5].set(point(1, 0, 1), point(0, 1, 1), point(0, 0, 1));
 
    pg[6].set(point(0, 0, 1), point(0, 1, 1), point(0, 1, 0));
    pg[7].set(point(0, 0, 1), point(0, 1, 0), point(0, 0, 0));
 
    pg[8].set(point(0, 1, 0), point(0, 1, 1), point(1, 1, 1));
    pg[9].set(point(0, 1, 0), point(1, 1, 1), point(1, 1, 0));
 
    pg[10].set(point(1, 0, 1), point(0, 0, 1), point(0, 0, 0));
    pg[11].set(point(1, 0, 1), point(0, 0, 0), point(1, 0, 0));
    srand(time(NULL));
    /*
    float map[50][50];
    for (int i = 0; i < 50; i++)
        for (int u = 0; u < 50; u++)
            map[i][u] = (rand() % 6);
            */
    /*
    * Сфера
    float val = 1;
    int hordet = 7;
    int verdet = 7;
    point vect(7, 0, 0);
    for (int i = 0; i < verdet; i++)
    for (int u = 0; u < hordet; u++)
    {
        float needit = 90 / float(verdet);
        point first = rotatevec(vect, int((360 / float(hordet * 2)) * (u * 2 + i)));
        point sec = rotatevec(vect, int((360 / float(hordet * 2)) * (u * 2 + 2 + i)));
        point thir = rotatevec(vect, int((360 / float(hordet * 2)) * (u * 2 + 1 + i)));
        first.x = first.x * (cos(i * needit * 0.0175));
        first.y = first.y * (cos(i * needit * 0.0175));
        sec.x = sec.x * (cos(i * needit * 0.0175));
        sec.y = sec.y * (cos(i * needit * 0.0175));
        thir.x = thir.x * (cos((i + 1) * needit * 0.0175));
        thir.y = thir.y * (cos((i + 1) * needit * 0.0175));
        thir.z = rotatevec(vect, 90 - ((i + 1) * 9)).x * val;
        first.z = rotatevec(vect, 90 - (i * 9)).x * val;
        sec.z = rotatevec(vect, 90 - (i * 9)).x * val;
        pg[i * hordet + u].set(first, sec, thir);
    }
    */
    /*
    int mapval = 12;
    for (int i = 0; i < 35; i++)
        for (int u = 0; u < 35; u++)
            pg[i * 35 + u].set(point(float(i * mapval), float(u * mapval), map[i][u] / 10), point(float(i * mapval) + mapval, float(u * mapval), map[i + 1][u] / 10), point(float(i * mapval), float(u * mapval) + mapval, map[i][u + 1] / 10));
    */
    bool inprog = true;
    float stuuff[5];
    float theta = 0;
    clock_t t = clock();
    RenderWindow window(sf::VideoMode(sw, sh), "3D nigga", Style::Fullscreen);
    while (inprog)
    {
        float timesgone = float(clock()) - float(t);
        int fps = int(1000 / timesgone);
        t = clock();
        theta += 0.1 * timesgone;
        //std::cout << int(1000 / timesgone) << std::endl;
        if (true)
        {
            //Управление
            float modif = 0.007 * timesgone;
            if (GetAsyncKeyState(27))
            {
                window.close();
                inprog = false;
            }
            if (GetAsyncKeyState(81))
            {
                cm.horangle += 5 * modif; needreview = true;
            }
            if (GetAsyncKeyState(69))
            {
                cm.horangle -= 5 * modif; needreview = true;
            }
            if (cm.horangle >= 360) cm.horangle -= 360;
            if (cm.horangle < 0) cm.horangle += 360;
            if (GetAsyncKeyState(67))
            {
                cm.pos.z += modif * 0.1; needreview = true;
            }
            if (GetAsyncKeyState(32))
            {
                cm.pos.z -= modif * 0.1; needreview = true;
            }
            if (GetAsyncKeyState(87))
            {
                cm.pos.x += cos(cm.horangle * 0.0175) * modif; needreview = true;
                cm.pos.y += sin(cm.horangle * 0.0175) * modif;
            }
            if (GetAsyncKeyState(83))
            {
                cm.pos.x -= cos(cm.horangle * 0.0175) * modif; needreview = true;
                cm.pos.y -= sin(cm.horangle * 0.0175) * modif;
            }
            if (GetAsyncKeyState(65))
            {
                cm.pos.x -= sin(cm.horangle * 0.0175) * modif; needreview = true;
                cm.pos.y += cos(cm.horangle * 0.0175) * modif;
            }
            if (GetAsyncKeyState(68))
            {
                cm.pos.x += sin(cm.horangle * 0.0175) * modif; needreview = true;
                cm.pos.y -= cos(cm.horangle * 0.0175) * modif;
            }
        }
        if (true)
        {
            if (needreview)
            {
                //needreview = false;
                window.clear();
                float lookangle = 60;
                float camx = cos(cm.horangle * 0.0175), camy = sin(cm.horangle * 0.0175), camz = sin(cm.verangle * 0.0175);
                point cmpos(cm.pos.x, cm.pos.y, cm.pos.z);
                for (int i = 0; i < hmpg; i++)
                {
                    if (dist(cm.pos, pointmid(pg[i].points[0], pointmid(pg[i].points[1], pg[i].points[2]))) <= 300)
                    {
                        point pointsonscreen[3];
                        float hval = (float(sw / 2)) * 1.4;
                        float vval = (float(sh / 2)) * 1.9;
                        int val = 200;
                        int cval = 1;
                        for (int u = 0; u < 3; u++)
                        {
                            /*
                            float Near = 0.1f;
                            float Far = 1000.0f;
                            float Fov = 90.0f;
                            float Ascpect = float(sh) / float(sw);
                            float FovRad = 1.0f / tanf(Fov * 0.5 * 0.0175);
                            float mat1[4][4] = { 0 };
                            mat1[0][0] = Ascpect * FovRad;
                            mat1[1][1] = FovRad;
                            mat1[2][2] = Far / (Far - Near);
                            mat1[3][2] = (-Far * Near) / (Far - Near);
                            mat1[2][3] = 1.0f;
                            mat1[3][3] = 0.0f;
                            float mat2[4][4] = { 0 };
                            mat2[0][0] = cosf(theta * 0.0175);
                            mat2[0][1] = sinf(theta * 0.0175);
                            mat2[1][0] = -sinf(theta * 0.0175);
                            mat2[1][1] = cosf(theta * 0.0175);
                            mat2[2][2] = 1;
                            mat2[3][3] = 1;
                            float mat3[4][4] = { 0 };
                            mat3[0][0] = 1;
                            mat3[1][1] = cosf(theta * 0.5f * 0.0175);
                            mat3[1][2] = sinf(theta * 0.5f * 0.0175);
                            mat3[2][1] = -sinf(theta * 0.5f * 0.0175);
                            mat3[2][2] = cosf(theta * 0.5f * 0.0175);
                            mat3[3][3] = 1;
                            point step1, step2;
                            domatrix(pg[i].points[u], step1, mat2);
                            domatrix(step1, step2, mat3);
                            step2.z += 3;
                            domatrix(step2, pointsonscreen[u], mat1);
                            pointsonscreen[u].x += 1;
                            pointsonscreen[u].y += 1;
                            pointsonscreen[u].x *= 0.5f * sw;
                            pointsonscreen[u].y *= 0.5f * sh;
                            */
                            point fromcamtothispoint((pg[i].points[u].x - cmpos.x) * 100, (pg[i].points[u].y - cmpos.y) * 100, 0.0f);
                            point wherecamlook(camx * 100, camy * 100, 0.0f);
                            float horanglebwit = whatisangle(fromcamtothispoint, wherecamlook);
                            float verangle;
                            verangle = whatisangle(point((pg[i].points[u].z - cmpos.z) * 100, lenght(fromcamtothispoint)), point(camz * 100, lenght(wherecamlook)));
                            bool wheredrawpointhor = false;
 
                            if (whatisangle(fromcamtothispoint, rotatevec(wherecamlook, 90)) * 100 < whatisangle(fromcamtothispoint, rotatevec(wherecamlook, 270)) * 100)
                                wheredrawpointhor = true;
 
                            
 
                            if (horanglebwit < 90)
                            {
                                if (wheredrawpointhor)
                                    pointsonscreen[u].x = int(sw / 2) - sin(horanglebwit * 0.0174533) * hval;
                                else
                                    pointsonscreen[u].x = int(sw / 2) + sin(horanglebwit * 0.0174533) * hval;
                            }
                            else
                            {
                                if (wheredrawpointhor)
                                    pointsonscreen[u].x = int(sw / 2) - (1 + sin((horanglebwit - 90) * 0.0174533)) * hval;
                                else
                                    pointsonscreen[u].x = int(sw / 2) + (1 + sin((horanglebwit - 90) * 0.0174533)) * hval;
                            }
 
                            if (pg[i].points[u].z * 100 > cmpos.z * 100)
                                pointsonscreen[u].y = int(sh / 2) - sin(verangle * 0.0174533) * vval;
                            else
                                pointsonscreen[u].y = int(sh / 2) + sin(verangle * 0.0174533) * vval;
 
                            if (GetAsyncKeyState(82))
                            {
                                Sleep(250);
                                cout << endl << pointsonscreen[u].y << "  " << pg[i].points[u].z << "  " << cmpos.z << "  " << verangle << endl;
                            }
                        }
                        CircleShape shape(1.f);
                        int color = 255 - cval * dist(cm.pos, pointmid(pg[i].points[0], pg[i].points[1]));
                        if (color < 0) color = 0;
                        shape.setFillColor(sf::Color(0, color, 0));
                        float distan = dist(pointsonscreen[0], pointsonscreen[1]);
                        float xgo = (pointsonscreen[0].x - pointsonscreen[1].x) / distan;
                        float ygo = (pointsonscreen[0].y - pointsonscreen[1].y) / distan;
                        float x, y;
                        x = pointsonscreen[0].x;
                        y = pointsonscreen[0].y;
                        while (x >= 0 && y >= 0 && x < sw && y < sh && (abs(pointsonscreen[1].x - x) > 1 || abs(pointsonscreen[1].y - y) > 1))
                        {
                            x -= xgo;
                            y -= ygo;
                            shape.setPosition(x, y);
                            window.draw(shape);
                        }
                        color = 255 - cval * dist(cm.pos, pointmid(pg[i].points[1], pg[i].points[2]));
                        if (color < 0) color = 0;
                        shape.setFillColor(sf::Color(0, color, 0));
                        distan = dist(pointsonscreen[1], pointsonscreen[2]);
                        xgo = (pointsonscreen[1].x - pointsonscreen[2].x) / distan;
                        ygo = (pointsonscreen[1].y - pointsonscreen[2].y) / distan;
                        x = pointsonscreen[1].x;
                        y = pointsonscreen[1].y;
                        while (x >= 0 && y >= 0 && x < sw && y < sh && (abs(pointsonscreen[2].x - x) > 1 || abs(pointsonscreen[2].y - y) > 1))
                        {
                            x -= xgo;
                            y -= ygo;
                            shape.setPosition(x, y);
                            window.draw(shape);
                        }
                        color = 255 - cval * dist(cm.pos, pointmid(pg[i].points[2], pg[i].points[0]));
                        if (color < 0) color = 0;
                        shape.setFillColor(sf::Color(0, color, 0));
                        distan = dist(pointsonscreen[2], pointsonscreen[0]);
                        xgo = (pointsonscreen[2].x - pointsonscreen[0].x) / distan;
                        ygo = (pointsonscreen[2].y - pointsonscreen[0].y) / distan;
                        x = pointsonscreen[2].x;
                        y = pointsonscreen[2].y;
                        while (x >= 0 && y >= 0 && x < sw && y < sh && (abs(pointsonscreen[0].x - x) > 1 || abs(pointsonscreen[0].y - y) > 1))
                        {
                            x -= xgo;
                            y -= ygo;
                            shape.setPosition(x, y);
                            window.draw(shape);
                        }
                    }
                }
                window.display();
            }
        }
        Event event;
        while (window.pollEvent(event))
        {
            if (event.type == Event::Closed)
                window.close();
        }
    }
    return 0;
}