Displaying interrupted line in OpenGL ES 2.0

I am rendering two lines simultaneously and also continuously using OpenGL ES 2.0 (NDK and C++ language) but randomly displaying interrupted line.

This issue happens once the line started to render but once line ends then it’s continuously rendering after that there is no issue. please suggest if you get any ideas.

Attached screenshot

Cross-ref:

As your reply there suggests, you’ve got to show us your OpenGL ES code. I’d also add, you should tell us what you’ve already tried to diagnose this, and what the results were.

Please see The Forum Posting Guidelines for other tips in composing your post to maximize your change of useful feedback.

Thank you very much for your update and updated CPP code in that link.

let us know anything further required. please try to help to resolve that issue.

(cpp code copied below:)

// get width and height from java layer

void JNICALL Java_com_greenline_OpenGL2JNILib_basicSetup(JNIEnv * env,
        jobject obj, jint width, jint height) 
{

    initialSetUp(width, height);
}

// Called to draw the current frame and call back from java layer of
// GLSurfaceView.Renderer interface

 void JNICALL Java_com_greenline_OpenGL2JNILib_step(JNIEnv * env,
        jobject obj) 
 {
    drawframe();
}

// receive data from java layer continuously

void JNICALL Java_com_greenline_OpenGL2JNILib_updateData(JNIEnv * env,
        jobject obj, jfloatArray points, jint pos, jint offset1, 
        jint len1,jint offset2, jint len2) 
{


    line[pos].len1 = len1;
    line[pos].offset1 = offset1;
    line[pos].len2 = len2;
    line[pos].offset2 = offset2;


       jsize length = env->GetArrayLength(points);
    jfloat *ele = env->GetFloatArrayElements(points, 0);

    memcpy(line[pos].vertices, ele, sizeof(jfloat) * length);
}


static const char VERTEX_SHADER[] = "attribute vec4 vPosition;\n"
        "void main() {\n"
        "  gl_Position = vPosition;\n"
        "}\n";

static const char FRAGMENT_SHADER[] = "precision mediump float;\n"
        "uniform vec4 userColor;"
        "void main() {\n"
        "  gl_FragColor = userColor.xyzw;\n"
        "}\n";

GLuint loadShader(GLenum shaderType, const char* source) 
{
    GLuint shader = glCreateShader(shaderType);
    if (shader) {
        glShaderSource(shader, 1, &source, NULL);
        glCompileShader(shader);
        GLint compiled = 0;
        glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
        if (!compiled) {
            GLint infoLen = 0;
            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
        }
    }
    return shader;
}

GLuint createProgram(const char* vertexSource, const char* fragmentSource) {
    GLuint vertexshader = loadShader(GL_VERTEX_SHADER, vertexSource);
    if (!vertexshader) {
        return 0;
    }

    GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER,
     fragmentSource);
    if (!fragmentShader) {
        return 0;
    }

    GLuint program = glCreateProgram();
    if (program) {
        glAttachShader(program, vertexShader);
        glAttachShader(program, fragmentShader);
        glLinkProgram(program);
        GLint linkStatus = GL_FALSE;
        glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
    }
    return program;
}

GLuint gProgram;
GLuint gvPositionHandle;
GLuint gUserColorHandle;


void initialSetUp(int w, int h) 
 {

    gProgram = createProgram(VERTEX_SHADER, FRAGMENT_SHADER);
    
    gvPositionHandle = glGetAttribLocation(gProgram, "vPosition");
    

    glViewport(0, 0, w, h);

    glLineWidth(1);
    
    gUserColorHandle = glGetUniformLocation(gProgram, "userColor");

    GLint iMultiSample = 0;
    GLint iNumSamples = 0;
    glGetIntegerv(GL_SAMPLE_BUFFERS, &iMultiSample);
    glGetIntegerv(GL_SAMPLES, &iNumSamples);

    return true;
}




struct greenLine_info {
    GLfloat *vertices;
    GLuint offset1;
    GLuint len1;
    GLuint offset2;
    GLuint len2;
    GLfloat w_color[4];
} greenLine_type ;


// to draw green lines
 void draw_greenLine(greenLine_type * line) 
{

    // first green line
        glEnableVertexAttribArray(gvPositionHandle);
        glVertexAttribPointer(gvPositionHandle, 2, GL_FLOAT, GL_FALSE, 
                              0,line->vertices);
        glDrawArrays(GL_LINE_STRIP, line->offset1, line->len1);


    // second green line
    glEnableVertexAttribArray(gvPositionHandle);
    glVertexAttribPointer(gvPositionHandle, 2, GL_FLOAT, GL_FALSE, 
                          0,line->vertices);
    glDrawArrays(GL_LINE_STRIP, line->offset2, line->len2);
}




void draw_SquareBox() 
{

    const float minValue = -1.0f;
    const float maxValue = 1.0f;

    unsigned char i = 0;

    float v = 0.0f;

    GLfloat *clr; // = { 0.2f, 0.2f, 0.2f, 1.0f };

    clr = (float*) malloc(sizeof(GLfloat) * 4);
    clr[0] = 0.2f;
    clr[1] = 0.2f;
    clr[2] = 0.2f;
    clr[3] = 1.0f;
    glUniform4fv(gUserColorHandle, 1, clr);
    free(clr);
    clr = NULL;
    checkGlError("dg_glUniform4fv");


        i = 0;
        while ((v=minValue +i * grid_x_factor) <= maxValue  && v >= 
               minValue ) 
                 {
                   draw_line(v, -1, v, 1);
                    ++i;
                  }
    
         j = 0;
        while ((v=maxValue - j * grid_y_factor) >= minValue && 
              v<=maxValue ) 
            {           
               draw_line(-1, v, 1, v);
                ++j;
            }
}

void draw_line(float x1, float y1, float x2, float y2) 
 {
    float *vertices =(float*) malloc(sizeof(float)*4);
    vertices[0]=x1;
    vertices[1]=y1;
    vertices[2]=x2;
    vertices[3]=y2;

    glVertexAttribPointer(gvPositionHandle, 2, GL_FLOAT, GL_FALSE, 0,   
     vertices);

    glEnableVertexAttribArray(gvPositionHandle);

    glDrawArrays(GL_LINES, 0, 2);

}


void drawframe() {
    
    renderSquareBoxes();

    for (i = 0; i < 2; i++) {
        draw_greenLine(&line[i]);
    }
}