Need help with a maze

Hello, I'm working on this maze but I want to make it where you can see the whole maze in the window and can move a ball within it with the mouse. Right now, the camera move around like 1st person within the maze. Are there any other imports I can use because I think it's the type of camera I added?

import queasycam.*;


Player player;
Maze maze;

void setup(){
  size(600, 600, P3D);
  strokeWeight(2);

  player = new Player(this);
  maze = new Maze(20);
  maze.setPlayerAtStart(player);
}

void draw(){
  background(51);
  maze.update();
  maze.display();
  player.update();
}


class Block {
  PVector position;
  PVector dimensions;
  color fillColor;
  boolean visited;

  Block(float x, float y, float z, float w, float h, float d){
    position = new PVector(x, y, z);
    dimensions = new PVector(w, h, d);
    fillColor = color(random(150, 200));
    visited = false;
  }

  void update(){
    float playerLeft = player.position.x - player.dimensions.x/2;
    float playerRight = player.position.x + player.dimensions.x/2;
    float playerTop = player.position.y - player.dimensions.y/2;
    float playerBottom = player.position.y + player.dimensions.y/2;
    float playerFront = player.position.z - player.dimensions.z/2;
    float playerBack = player.position.z + player.dimensions.z/2;

    float boxLeft = position.x - dimensions.x/2;
    float boxRight = position.x + dimensions.x/2;
    float boxTop = position.y - dimensions.y/2;
    float boxBottom = position.y + dimensions.y/2;
    float boxFront = position.z - dimensions.z/2;
    float boxBack = position.z + dimensions.z/2;

    float boxLeftOverlap = playerRight - boxLeft;
    float boxRightOverlap = boxRight - playerLeft;
    float boxTopOverlap = playerBottom - boxTop;
    float boxBottomOverlap = boxBottom - playerTop;
    float boxFrontOverlap = playerBack - boxFront;
    float boxBackOverlap = boxBack - playerFront;

    if (((playerLeft > boxLeft && playerLeft < boxRight || (playerRight > boxLeft && playerRight < boxRight)) && ((playerTop > boxTop && playerTop < boxBottom) || (playerBottom > boxTop && playerBottom < boxBottom)) && ((playerFront > boxFront && playerFront < boxBack) || (playerBack > boxFront && playerBack < boxBack)))){
      float xOverlap = max(min(boxLeftOverlap, boxRightOverlap), 0);
      float yOverlap = max(min(boxTopOverlap, boxBottomOverlap), 0);
      float zOverlap = max(min(boxFrontOverlap, boxBackOverlap), 0);

      if (xOverlap < yOverlap && xOverlap < zOverlap){
        if (boxLeftOverlap < boxRightOverlap){
          player.position.x = boxLeft - player.dimensions.x/2;
        } else {
          player.position.x = boxRight + player.dimensions.x/2;
        }
      }

      else if (yOverlap < xOverlap && yOverlap < zOverlap){
        if (boxTopOverlap < boxBottomOverlap){
          player.position.y = boxTop - player.dimensions.y/2;
          player.velocity.y = 0;
          player.grounded = true;
        } else {
          player.position.y = boxBottom + player.dimensions.y/2;
        }
      }

      else if (zOverlap < xOverlap && zOverlap < yOverlap){
        if (boxFrontOverlap < boxBackOverlap){
          player.position.z = boxFront - player.dimensions.x/2;
        } else {
          player.position.z = boxBack + player.dimensions.x/2;
        }
      }
    }
  }

  void display(){
    pushMatrix();
    translate(position.x, position.y, position.z);
    fill(fillColor, 200);
    box(dimensions.x, dimensions.y, dimensions.z);
    popMatrix();
  }

  void moveDown(){
    position.y += 5;
  }
}

class Player extends QueasyCam {
  PVector dimensions;
  PVector velocity;
  PVector gravity;
  boolean grounded;

  Player(PApplet applet){
    super(applet);
    speed = 0.04;
    dimensions = new PVector(1, 3, 1);
    velocity = new PVector(0, 0, 0);
    gravity = new PVector(0, 0.01, 0);
    grounded = false;
  }

  void update(){
    velocity.add(gravity);
    position.add(velocity);

    if (grounded && keyPressed && key == ' '){
      grounded = false;
      velocity.y = -0.5;
      position.y -= 0.1;
    }
  }
}

class Maze {
  Block[][] blocks;
  Block start;
  Block end;

  Maze(int size){
    blocks = new Block[size][size];

    for (int i=0; i<size; i++){
      for (int j=0; j<size; j++){
        float x = i * 5;
        float y = 0;
        float z = j * 5;
        blocks[i][j] = new Block(x, y, z, 5, 5, 5);
      }
    }

    int row = int(random(1, size-1));
    int col = int(random(1, size-1));
    start = blocks[row][col];

    for (int i=0; i<size*size*size/10; i++){
      if (!blocks[row][col].visited) blocks[row][col].moveDown();
      blocks[row][col].visited = true;

      if (random(0, 1) < 0.5){
        if (random(0, 1) < 0.5 && row > 1) row -= 1;
        else if (row < size-2) row += 1;
      } else {
        if (random(0, 1) < 0.5 && col > 1) col -= 1;
        else if (col < size-2) col += 1;
      }
    }
  }

  void update(){
    for (int i=0; i<blocks.length; i++){
      for (int j=0; j<blocks[i].length; j++){
        blocks[i][j].update();
      }
    }
  }

  void display(){
    for (int i=0; i<blocks.length; i++){
      for (int j=0; j<blocks[i].length; j++){
        blocks[i][j].display();
      }
    }
  }

  void setPlayerAtStart(Player player){
    player.position = PVector.add(start.position, new PVector(0, -15, 0));
  }
}