void GlWidget::stencilIntersection()

        {

            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

            updateTransforms();

            glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);// отключили запись во все буферы

            glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);// включили увеличение стенсила при каждом пересечении

            drawTrack(m_trackColor);// отрисовали трек, причем, получается, что на каждом пересечении значение в стенсиле увеличилось на единичку, так?

            glStencilMask(0);// отключаем запись в стенсил

            glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

            glStencilFunc(GL_EQUAL, 1, 0b111);

            m_trackColor = Qt::white;//там где стенисил единичка - рисуем белым

            drawTrack(m_trackColor);// отрисовали трек белым цветом

            glStencilFunc(GL_EQUAL, 2, 0b111);

            m_trackColor = Qt::red;// там где стенсил двоечка - рисуем бледно красным

            drawTrack(m_trackColor);// отрисовали трек

 

            glStencilFunc(GL_EQUAL, 3, 0b111);

            glClearStencil(0);

            m_trackColor = Qt::darkRed;// там где стенсил троечка - рисуем темно красным

            drawTrack(m_trackColor);

            drawCenterLine();

            m_trackProgram.bind();

            calculateFps();

 

        }

            glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);// отключили запись во все буферы

    void SnowGlWidget::initializeGL()

    {

        glEnable(GL_DEPTH_TEST);

        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

        glStencilMask(0x00);

        glStencilFunc(GL_ALWAYS, 1, 0xFF);

        glStencilMask(0xFF);

 

        QGLShader vShader(QGLShader::Vertex);

        if(!vShader.compileSourceCode(

                    "attribute vec3 vertexPosition;\n"

                    "uniform mat4 modelViewProjMatrix;\n"

                    "attribute highp vec4 vertexAttr;\n"

                    "attribute lowp vec4 colorAttr;\n"

                    "varying lowp vec4 color;\n"

                    "void main()\n"

                    "{\n"

                        "color = colorAttr;\n"

                        "gl_Position = modelViewProjMatrix * vec4(vertexPosition, 1.0);\n"

                    "}\n"

                    )) {

            return;

        }

        QGLShader fShader(QGLShader::Fragment);

        if(!fShader.compileSourceCode(

                                  "varying lowp vec4 color;\n"

                                  "void main()\n"

                                  "{\n"

                                     " gl_FragColor = color;\n"

                                  "}\n"

                                      )) {

            QMessageBox::critical(0, tr("ERROR"), fShader.log(),

                                  QMessageBox::Ok);

            return;

        }

 

        if(!m_program.addShader(&vShader)){

            return;

        }

        if(!m_program.addShader(&fShader)){

            return;

        }

        if (!m_program.link()) {

            return;

        }

        if (!m_program.bind()) {

            return;

        }

        m_vertexAttr = m_program.attributeLocation("vertexAttr");

        m_colorAttr = m_program.attributeLocation("colorAttr");

        m_track = new SnowTrack(&m_program, m_vertexAttr, m_colorAttr, m_points);

        m_perspective.aspectRatio = height() > 0.0f ? float(width()) / float(height()) : 1.0f;

    }

void SnowGlWidget::paintGL()

    {

        qglClearColor(QColor(32,64,128,0));

        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

        glStencilMask(0x00);

        glStencilFunc(GL_ALWAYS, 1, 0xFF);

        glStencilMask(0xFF);

        m_projectionMat.setToIdentity();

        m_projectionMat.perspective(

                    m_perspective.verticalAngle,

                    m_perspective.aspectRatio,

                    m_perspective.nearPlane,

                    m_perspective.farPlane);

 

        m_viewMat.setToIdentity();

        m_viewMat.lookAt(m_lookAt.eye, m_lookAt.center, m_lookAt.up);

 

        m_modelMat.setToIdentity();

        m_modelMat.scale(m_modelScale);

        m_modelMat.rotate(m_angle,-0.f,0.f,1);

        m_modelMat.translate(m_modelTranslation);

 

        m_program.setUniformValue("normalMatrix", m_modelMat.normalMatrix()); // world normal

        m_program.setUniformValue("modelViewMatrix", m_viewMat * m_modelMat);

        m_program.setUniformValue("projectionMatrix", m_projectionMat);

        m_program.setUniformValue("modelViewProjMatrix", m_projectionMat * m_viewMat * m_modelMat);

 

        m_program.setUniformValue("lightPosition", m_lightPosition);

        m_program.setUniformValue("lightKd", m_lightKd);

        m_program.setUniformValue("lightLd", m_lightLd);

        m_track->draw();

        calculateFps();

    }

    void SnowTrack::drawTest()

    {

        m_vertices << -0.5f << -0.5f << 0.0f;

        m_vertices << 0.5f << -0.5f << 0.0f;

        m_vertices << 0.0f << 0.5f << 0.0f;

 

        m_vertices << -0.2f << -0.5f << 0.0f;

        m_vertices << 0.8f << -0.5f << 0.0f;

        m_vertices << 0.2f << 0.5f << 0.0f;

 

        m_colors << 0.f << 1.f << 0.f;

        m_colors << 0.f << 1.f << 0.f;

        m_colors << 0.f << 1.f << 0.f;

 

        m_colors << 1.f << 1.f << 0.f;

        m_colors << 1.f << 1.f << 0.f;

        m_colors << 1.f << 1.f << 0.f;

 

    }

        void SnowTrack::draw()

    {

        m_program->enableAttributeArray("vertexPosition");

        m_program->setAttributeArray("vertexPosition", m_vertices.data(), 3);

        m_program->setAttributeArray(m_colorAttr, m_colors.data(), 3);

        m_program->enableAttributeArray(m_colorAttr);

                glDrawArrays(GL_TRIANGLE_STRIP, 0, m_vertices.size() / 3);

        m_program->disableAttributeArray(m_vertexAttr);

        m_program->disableAttributeArray(m_colorAttr);

    }