for (int i = 0 ;i < polygons.size(); ++i){
        polygons[i] *= resultRotate;


    }

/*    std::cout << "________________\n";
    for (int i = 0; i < polygons.size(); ++i)
        std::cout << polygons[i].leastDistant() << '\n';
*/
    QBrush q;
    QPen wp;
    std::sort(polygons.begin(), polygons.end());
    for (int i = 0; i < polygons.size(); ++i){
        if (polygons[i].Normal().data[2] > 0)
            continue;
        polygons[i].color.data[0] = 255;
        polygons[i].color.data[1] = 0;
        polygons[i].color.data[1] = 0;

        if (lightning == Phong || lightning == Cook){
            Vector center = polygons[i].points[0] +polygons[i].points[1] +polygons[i].points[2];
            for (int r = 0; r < 3; ++r)
                center.data[r] /= 3;
            Vector L =  light_source - center;
            Vector N  = polygons[i].Normal();
            Vector V = POV - center;
            Vector H = V + L;
            if (L.length() != 0){
                double sz = L.length();
                L.data[0] /= sz;
                L.data[1] /= sz;
                L.data[2] /= sz;

            }
            if (V.length() != 0){
                double sz = V.length();
                V.data[0] /= sz;
                V.data[1] /= sz;
                V.data[2] /= sz;

            }
            if (N.length() != 0){
                double sz = N.length();

                N.data[0] /= sz;
                N.data[1] /= sz;
                N.data[2] /= sz;
            }
            if (H.length() != 0){
                double sz = H.length();
                H.data[0] /= sz;
                H.data[1] /= sz;
                H.data[2] /= sz;
            }


            double dot_prodLN =  (L.data[0] * N.data[0] + L.data[1] * N.data[1] + L.data[2] * N.data[2]);
            double dot_prodHN = (H.data[0] * N.data[0] + H.data[1] * N.data[1] + H.data[2] * N.data[2]);

            if (L.length() == 0 || N.length() == 0)
                polygons[i].color = Vector();
            else{
                polygons[i].color.data[0] = Diffuse[0] * dot_prodLN * 255.0 ;
                polygons[i].color.data[1] = Diffuse[1]  * dot_prodLN * 255.0;
                polygons[i].color.data[2] = Diffuse[2]  * dot_prodLN * 255.0;
            }
            if (H.length() == 0)
                polygons[i].color = Vector();
            else {
                if (lightning == Phong){

                    dot_prodHN *= dot_prodHN;
                    polygons[i].color.data[0] +=  Specular[0] * dot_prodHN * 255;
                    polygons[i].color.data[1] +=  Specular[1] * dot_prodHN * 255;
                    polygons[i].color.data[2] +=  Specular[2] * dot_prodHN * 255;
                }

                if (lightning == Cook){
                    double dot_prodVN = V.data[0] * N.data[0] +V.data[1] * N.data[1] +V.data[2] * N.data[2];
                    double dot_prodVH = V.data[0] * H.data[0] +V.data[1] * H.data[1] +V.data[2] * H.data[2];

                    double G = 1.0;
                    double temp = 2.0 * dot_prodHN * dot_prodVN / dot_prodVH;
                    if (temp < G)
                        G = temp;
                    temp = 2.0 * dot_prodHN * dot_prodLN / dot_prodVH;

                    if (temp < G)
                        G = temp;
                    double D =  1.0/(m*m * dot_prodHN* dot_prodHN* dot_prodHN* dot_prodHN);
                    D *= exp(dot_prodHN * dot_prodHN - 1.0 / (m*m * dot_prodHN * dot_prodHN));
                    double F = 1.0 / (1 + dot_prodVN);
                    double K = F*G*D/(dot_prodVN * dot_prodLN);

                    polygons[i].color.data[0] +=  Specular[0] * K * 255;

                    polygons[i].color.data[1] += Specular[1] * K * 255;

                    polygons[i].color.data[2] += Specular[2] * K * 255;

                }
            }

            polygons[i].color.data[0] = min(255, polygons[i].color.data[0]  + Ambient[0] * 255);
            if (polygons[i].color.data[0] < 0)
                polygons[i].color.data[0] = 0;

            polygons[i].color.data[1] = min(255, polygons[i].color.data[1]  + Ambient[1] * 255);
            if (polygons[i].color.data[1] < 0)
                polygons[i].color.data[1] = 0;

            polygons[i].color.data[2] = min(255, polygons[i].color.data[2]  + Ambient[2] * 255);
            if (polygons[i].color.data[2] < 0)
                polygons[i].color.data[2] = 0;
        }


        if (projection)
            polygons[i] *= ScaleShift * projectionMat;
       else
            polygons[i] *=  ScaleShift;

        QPoint tri[3];
        tri[0].setX(polygons[i].points[0].data[0]);
        tri[0].setY(polygons[i].points[0].data[1]);

        tri[1].setX(polygons[i].points[1].data[0]);
        tri[1].setY(polygons[i].points[1].data[1]);

        tri[2].setX(polygons[i].points[2].data[0]);
        tri[2].setY(polygons[i].points[2].data[1]);





        if (lightning == None){
            wp.setColor(Qt::black);
            q.setStyle(Qt::NoBrush);
        }

        if (lightning == Solid){
        wp.setColor(Qt::black);
        q.setColor(Qt::red);
        q.setStyle(Qt::SolidPattern);
        }

        if (lightning == Phong || lightning == Cook){
            QColor ss;
            ss.setRed(polygons[i].color.data[0]);
            ss.setGreen(polygons[i].color.data[1]);
            ss.setBlue(polygons[i].color.data[2]);
            wp.setColor(ss);
            q.setColor(ss);
            q.setStyle(Qt::SolidPattern);


        }
        p.setBrush(q);
        p.setPen(wp);

        p.drawPolygon(tri, 3);
    }


 /*   wp.setColor(Qt::black);
    p.setPen(wp);
    Vector t = ScaleShift  * resultRotate * light_source;
    p.drawLine(0,0, t.data[0], t.data[1]);
*/
}