I don't think so, draw() is an important function in processing, which is neccessary to make the sketch animated or interactive. You could just show the triangle depending on a condition, and only show the triangle when e.g. enter has been pressed at least 5 times.

1. int count =0;
   void setup(){
    size(400, 400);
   }
   
   void draw(){
     background(0);
     text("enter has been pressed "+count +" times.", 50, 50);
     if(count >= 5){
       triangle(200, 240, 220, 200, 240, 240);
     }
   }
   
   void keyPressed(){
     if(key == ENTER){
       count ++;
     }
   }
   

It's confusing if you come from a more 'traditional' programming background isn't it? Here's what I'm doing to solve this sort of issue in a little game (but I'm newish to Processing too so there may be 'better' ways)...

pseudo code

draw(){

      switch(player.context)

      case 1
      player.menu()

      case 2
      player.ingame()

      case 3
      player.gameover()

      etc..
}

The menu and ingame methods of the player class execute then return to the draw() loop for the screen to be updated.

I don't have anything else inside draw() as the player 'context' is updated as required in each of the methods; it might be set to 'game over' (3 in the above pseudocode) for example by the ingame() method when the player dies.

It just means that there's a function call/return overhead for each cycle in the main loop that you might not have if all discrete parts of your game were in self-contained functions.

Stuff that needs to be .remembered' between calls is either stored in the class (for example player position) or in a global variable (wait for it!).

Seems to work so far :D

Its possible to "register" an object with the PApplet to have its specific methods called when certain events occur. For example, a class can have its own draw() method and have it called on instances automatically by the PApplet each time through the draw() loop. You might want to have a look. The method of registration for the development version of Processing is or will be changed a little from the wiki, but its the same general idea.

Thanks rbrauer. I didn't know that. Found it very interesting.

"For example, a class can have its own draw() method and have it called on instances automatically by the PApplet each time through the draw() loop."

That seems much more elegant (and easier to comprehend than I expected!) but does execution actually have to return to the draw() loop for these class draw() methods to be called? If so it seems no different in essence to my arrangement.

Here's one quick way to do it - changed code from the end of your global declarations to the end of draw() :

Boolean flagGo = false;

void setup() {
  size(400, 400);

}

void draw() {
 
    if(!flagGo)
      beginScreen();
     else
      drawTriangle();
     
     if(keyPressed){
         flagGo=true; // pressed a key wants to continue to triangle control
         background(#CCCCCC); // removes your text
     }
    
 
 
}

Begin beginScreen;
Tri tri;

void setup() {
  size(400,400);
  textAlign(CENTER);
  
  beginScreen = new Begin("beginScreen");
}

void draw() {
  background(#cccccc);
}

void keyReleased() {
  if(keyCode == ENTER) {
    print("!");
    unregisterDraw(beginScreen);
    PVector[] vt = 
      new PVector[] {
        new PVector(200,200),
        new PVector(220,160),
        new PVector(240,200)
      };
    tri = new Tri(vt);
  }
  if(tri != null) {
    if(keyCode == UP) tri.offset(new PVector(0,-40));
    if(keyCode == DOWN) tri.offset(new PVector(0,40));
    if(keyCode == LEFT) tri.offset(new PVector(-40,0));
    if(keyCode == RIGHT) tri.offset(new PVector(40,0));
  }
}

public class Begin {
  String message;
  
  Begin(String message) {
    this.message = message;
    registerDraw(this);
  }
  
  public void draw() {
    fill(#ff0000);
    text(message, width*.5, height*.5);
  }
}

public class Tri {
  PVector[] verts;
  
  Tri(PVector[] verts) {
    this.verts = verts;
    registerDraw(this);
  }
  
  void offset(PVector offs) {
    for(PVector cur : verts) {
      cur.add(offs);
    }
  }
  
  public void draw() {
    fill(#ffffff);
//    triangle(
//      verts[0].x, verts[0].y,
//      verts[1].x, verts[1].y,
//      verts[2].x, verts[2].y);
      
    beginShape(TRIANGLES);
    for(PVector cur : verts) {
      vertex(cur.x, cur.y);
    }
    endShape();
  }
  
}