In Processing setup() is called just once to set display size and renederer with the size() method then initialise any variables.

The draw() method is called to create each frame to be rendered so it will produce just a single frame.

In the code below I have created an offscreen graphics context called bg this is created in line 15 and immediatetly cleared to black, set to smooth and a stroke weight of 10 (lines 16-20)

In draw thw main display is cleared to bg a random line is then drawn to bg and then the ball is drawn. The variable count is incremented each frame and then line 41 take the modulo (remainder after division) with the screen with effectively making count loop through the range 0 to (width - 1)

In Processing background() is used to clear the display to a colour or an image so should only appear once in the draw() method and before any drawing commands.

1. import processing.opengl.*;
2. 
   
3. float xpos;
4. float ypos;
5. int ballWth ;
6. int ballHgt ;
7. float xspeed ;
8. float yspeed ;
9. int count = 0;
10. 
    
11. PGraphics bg;
12. 
    
13. void setup() {
14.   size(800, 600, OPENGL);
15.   bg = createGraphics(width, height, JAVA2D);
16.   bg.beginDraw();
17.   bg.background(0);
18.   bg.smooth();
19.   bg.strokeWeight(10);
20.   bg.endDraw();
21.   smooth();
22.   background(0);
23.   strokeWeight(10);
24.   noStroke();
25.   frameRate(200);
26.   smooth();
27.   xpos = width/2.0;
28.   ypos = height/2.0;
29.   xspeed = .3+random(2.5);
30.   yspeed = .3+random(2.5);
31.   ballWth = 80;
32.   ballHgt = 80;
33. }
34. void draw() {
35.   smooth();
36.   background(bg);
37.   strokeWeight(10);
38.   float r = random(255);
39.   float x = random(0, width);
40.   count++;
41.   count %= width;
42.   bg.beginDraw();
43.   bg.stroke(r, 100);
44.   bg.line(count++ % width, 0, x, height);
45.   bg.endDraw();
46. 
    
47.   // Animation
48.   fill(0, 162, 142);
49.   ellipse(xpos, ypos, ballWth, ballHgt);
50.   xpos += xspeed;
51.   ypos += yspeed; 
52.   if (xpos >= width  || xpos <=0) {
53.     xspeed *= -1;
54.   }
55.   if (ypos >= height || ypos <= 0) {
56.     yspeed *=-1;
57.   }
58. }

The ball is not visible in OPENGL but is if you use P3D or JAVA2D and I am not sure why. If you change the draw method to the one shown below it will work in OPENGL but is very slow compared to the other renderers. It appears to be the image() method there might be a quicker way but it is probably OpenGL creating a new texture every frame.

1. void draw() {
2.   smooth();
3.   background(0);
4.   strokeWeight(10);
5.   float r = random(255);
6.   float x = random(0, width);
7.   count++;
8.   count %= width;
9.   bg.beginDraw();
10.   bg.stroke(r, 100);
11.   bg.line(count++ % width, 0, x, height);
12.   bg.endDraw();
13.   image(bg,0,0);
14.   // Animation
15.   fill(0, 162, 142);
16.   ellipse(xpos, ypos, ballWth, ballHgt);
17.   xpos += xspeed;
18.   ypos += yspeed; 
19.   if (xpos >= width  || xpos <=0) {
20.     xspeed *= -1;
21.   }
22.   if (ypos >= height || ypos <= 0) {
23.     yspeed *=-1;
24.   }
25. }