Examples of net.java.games.input.Keyboard

net.java.games.input.Keyboard
A Keyboard is a type of controller consisting of a single controller, they keypad, which contains several axes (the keys). By default, all keys are set to receive polling data.

    CaptureDemo demo = new CaptureDemo();
    demo.start(ServiceLoader.load(ch.blackspirit.graphics.CanvasFactory.class).iterator().next());
  }
  public void start(ch.blackspirit.graphics.CanvasFactory factory) throws IOException {
    ControllerEnvironment controllerEnv = ControllerEnvironment.getDefaultEnvironment();
    Keyboard keyboard = null;
    for(Controller controller: controllerEnv.getControllers()) {
      if(controller.getType() == Type.KEYBOARD) {
        keyboard = (Keyboard)controller;
        break;
      }
    }


    canvas = factory.createRealtimeCanvasWindow(400, 300);


    canvas.setVSync(true);
    canvas.addWindowListener(WindowListener.EXIT_ON_CLOSE);
    canvas.setWindowTitle("Capture Demo");
    
    final Image save = canvas.getImageFactory().createBufferedImage(400, 300, BufferTypes.RGB_3Byte);


    final Image animLeftImage = canvas.getImageFactory().createBufferedImage(
        CaptureDemo.class.getResource("/sprites/Crono - Walk (Left) 44x68.png"), false);
    Image animFrontImage = canvas.getImageFactory().createImage(
        CaptureDemo.class.getResource("/sprites/Crono - Walk (Front) 40x70.png"), false);
    Image animBackImage = canvas.getImageFactory().createImage(
        CaptureDemo.class.getResource("/sprites/Crono - Walk (Back) 36x70.png"), false);
    Image leftImage = canvas.getImageFactory().createImage(
        CaptureDemo.class.getResource("/sprites/Crono (Left).png"), false);
    Image frontImage = canvas.getImageFactory().createImage(
        CaptureDemo.class.getResource("/sprites/Crono (Front).png"), false);
    Image backImage = canvas.getImageFactory().createImage(
        CaptureDemo.class.getResource("/sprites/Crono (Back).png"), false);
    final Image grass = canvas.getImageFactory().createImage(
        CaptureDemo.class.getResource("/sprites/grass.png"), false);
    final Image wall = canvas.getImageFactory().createImage(
        CaptureDemo.class.getResource("/sprites/wall.png"), false);


    canvas.getResourceManager().cacheImage(animLeftImage);
    canvas.getResourceManager().cacheImage(animFrontImage);
    canvas.getResourceManager().cacheImage(animBackImage);
    canvas.getResourceManager().cacheImage(leftImage);
    canvas.getResourceManager().cacheImage(frontImage);
    canvas.getResourceManager().cacheImage(backImage);
    canvas.getResourceManager().cacheImage(grass);  
    canvas.getResourceManager().cacheImage(wall);


    // Setting up the animations
    final Animation<Frame> animLeft = new AnimationImpl<Frame>();
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000, 0, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000, 45, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000, 90, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000,135, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000,180, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000,225, 0, 44, 68));
    animLeft.setRepeated(true);
    
    final Animation<Frame> animFront = new AnimationImpl<Frame>();
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000, 0, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000, 41, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000, 82, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000,123, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000,164, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000,205, 0, 40, 70));
    animFront.setRepeated(true);
    
    
    final Animation<Frame> animLeftStill = new AnimationImpl<Frame>();
    animLeftStill.addFrame(new FrameImpl(leftImage, 160000000, 0, 0, 28, 68));
    animLeftStill.setRepeated(true);
    
    final Animation<Frame> animFrontStill = new AnimationImpl<Frame>();
    animFrontStill.addFrame(new FrameImpl(frontImage, 160000000, 0, 0, 32, 70));
    animFrontStill.setRepeated(true);
    
    final Animation<Frame> animBackStill = new AnimationImpl<Frame>();
    animBackStill.addFrame(new FrameImpl(backImage, 160000000, 0, 0, 32, 66));
    animBackStill.setRepeated(true);
    
    final Animation<Frame> animBack = new AnimationImpl<Frame>();
    animBack.addFrame(new FrameImpl(animBackImage, 160000000, 0, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000, 37, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000, 74, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000,111, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000,148, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000,185, 0, 36, 70));
    animBack.setRepeated(true);
    
    final Color4f white = new Color4f(1,1,1,1);
    final Color4f red = new Color4f(1,0,0,1);


    canvas.setGraphicsListener(new GraphicsListener() {
      long start = System.nanoTime();
      long currTime = start;
      long count = 0;
      long fps = 0;
  
      Animation<Frame> walk = animFrontStill;
      Flip flip = Flip.NONE;
      int xOffset = 0;


      public void draw(View view, Graphics renderer) {
        long elapsedTime = System.nanoTime() - currTime;
        currTime += elapsedTime;
        
        animLeft.update(elapsedTime);
        animFront.update(elapsedTime);
        animBack.update(elapsedTime);


        renderer.setColor(white);


        // Background
        for(int x = 0; x <= 400; x+=grass.getWidth() * 2) {
          for(int y = 0; y <= 300; y+=grass.getHeight() * 2) {
            renderer.translate(-x, -y);
            renderer.drawImage(grass, grass.getWidth() * 2, grass.getHeight() * 2);
            renderer.clearTransformation();
          }
        }
  
        for(int x = 0; x <= 400; x+=wall.getWidth() * 2) {
          renderer.translate(-x, -160);
          renderer.drawImage(wall, wall.getWidth() * 2, wall.getHeight() * 2);
          renderer.clearTransformation();
        }
      
        if(up && !down) {
          posY -= (float)elapsedTime / 11000000;
          walk = animBack;
          flip = Flip.NONE;
          xOffset = 0;
        } else if(down && !up) {
          posY += (float)elapsedTime / 11000000;
          walk = animFront;
          flip = Flip.NONE;
          xOffset = 0;
        } else if(left && !right) {
          posX -= (float)elapsedTime / 10000000;
          walk = animLeft;
          flip = Flip.NONE;
          xOffset = 0;
        } else if(right && !left) {
          posX += (float)elapsedTime / 10000000;
          walk = animLeft;
          flip = Flip.VERTICAL;
          xOffset = 0;
        } else {
          if(walk == animLeft) {
            walk = animLeftStill; 
            if(flip == Flip.NONE) xOffset = 4;
            else xOffset = 8;
          }
          if(walk == animFront) {
            walk = animFrontStill; 
            xOffset = 3;
          }
          if(walk == animBack) {
            walk = animBackStill; 
            xOffset = 1;
          }
        }
        
        renderer.clearTransformation();
        renderer.translate(-(posX + xOffset), -posY);
        walk.draw(renderer, walk.getWidth(), walk.getHeight(), flip);
        
        renderer.setColor(red);
        renderer.clearTransformation();
        renderer.translate(-250, -280);
        renderer.drawText("FPS:" + fps);
        
        if(doSave) {
          // Copy the content of the canvas
          renderer.copyToImage(save);
        }
        
        count++;
        if(currTime - start > 1000000000) {
          start = currTime;
          fps = count;
          count = 0;
          System.out.println(fps);
        }
      }


      public void init(View view, Graphics renderer) {
        view.setCamera(200, 150, 0);
        view.setSize(400, 300);
      }


      public void sizeChanged(GraphicsContext canvas, View view) {}
      
    });


  
    // Cleanup
    System.gc();
    
    // Starting the rendering
    long lastVSyncChange = 0;
    while(true) {
      if(keyboard != null) {
        keyboard.poll();
      
        // End demo
        if(keyboard.isKeyDown(Key.Q) || keyboard.isKeyDown(Key.ESCAPE)) {
          canvas.dispose();
          System.exit(0);
        }
        // VSync
        if(keyboard.isKeyDown(Key.S)) {
          long time = System.currentTimeMillis();
          if(time - lastVSyncChange > 1000) {
            canvas.setVSync(!canvas.getVSync());
            lastVSyncChange = time;
          }
        }
        
        // Character movement
        down = keyboard.isKeyDown(Key.DOWN);
        left = keyboard.isKeyDown(Key.LEFT);
        right = keyboard.isKeyDown(Key.RIGHT);
        up = keyboard.isKeyDown(Key.UP);


        doSave = keyboard.isKeyDown(Key.I);
      }


      
      canvas.draw();

View Full Code Here

    ImageDemo demo = new ImageDemo();
    demo.start(ServiceLoader.load(ch.blackspirit.graphics.CanvasFactory.class).iterator().next());
  }
  public void start(ch.blackspirit.graphics.CanvasFactory factory) throws IOException {
    ControllerEnvironment controllerEnv = ControllerEnvironment.getDefaultEnvironment();
    Keyboard keyboard = null;
    for(Controller controller: controllerEnv.getControllers()) {
      if(controller.getType() == Type.KEYBOARD) {
        keyboard = (Keyboard)controller;
        break;
      }
    }


    // Create a fullscreen realtime canvas using the current display mode.
    DisplayMode mode = factory.getDisplayMode(800, 600);
    if(mode != null) {
      canvas = factory.createRealtimeCanvasFullscreen(mode);
    } else {
      canvas = factory.createRealtimeCanvasFullscreen();
    }


    canvas.setVSync(true);
    canvas.addWindowListener(WindowListener.EXIT_ON_CLOSE);
    canvas.setWindowTitle("Image Render Demo");
    
    final Image animLeftImage = canvas.getImageFactory().createImage(
        ImageDemo.class.getResource("/sprites/Crono - Walk (Left) 44x68.png"), false);
    Image animFrontImage = canvas.getImageFactory().createImage(
        ImageDemo.class.getResource("/sprites/Crono - Walk (Front) 40x70.png"), false);
    Image animBackImage = canvas.getImageFactory().createImage(
        ImageDemo.class.getResource("/sprites/Crono - Walk (Back) 36x70.png"), false);
    Image leftImage = canvas.getImageFactory().createImage(
        ImageDemo.class.getResource("/sprites/Crono (Left).png"), false);
    Image frontImage = canvas.getImageFactory().createImage(
        ImageDemo.class.getResource("/sprites/Crono (Front).png"), false);
    Image backImage = canvas.getImageFactory().createImage(
        ImageDemo.class.getResource("/sprites/Crono (Back).png"), false);
    final Image grass = canvas.getImageFactory().createImage(
        ImageDemo.class.getResource("/sprites/grass.png"), false);
    final Image wall = canvas.getImageFactory().createImage(
        ImageDemo.class.getResource("/sprites/wall.png"), false);


    canvas.getResourceManager().cacheImage(animLeftImage);
    canvas.getResourceManager().cacheImage(animFrontImage);
    canvas.getResourceManager().cacheImage(animBackImage);
    canvas.getResourceManager().cacheImage(leftImage);
    canvas.getResourceManager().cacheImage(frontImage);
    canvas.getResourceManager().cacheImage(backImage);
    canvas.getResourceManager().cacheImage(grass);  
    canvas.getResourceManager().cacheImage(wall);


    // Setting up the animations
    final Animation<Frame> animLeft = new AnimationImpl<Frame>();
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000, 0, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000, 45, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000, 90, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000,135, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000,180, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000,225, 0, 44, 68));
    animLeft.setRepeated(true);
    
    final Animation<Frame> animFront = new AnimationImpl<Frame>();
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000, 0, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000, 41, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000, 82, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000,123, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000,164, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000,205, 0, 40, 70));
    animFront.setRepeated(true);
    
    
    final Animation<Frame> animLeftStill = new AnimationImpl<Frame>();
    animLeftStill.addFrame(new FrameImpl(leftImage, 160000000, 0, 0, 28, 68));
    animLeftStill.setRepeated(true);
    
    final Animation<Frame> animFrontStill = new AnimationImpl<Frame>();
    animFrontStill.addFrame(new FrameImpl(frontImage, 160000000, 0, 0, 32, 70));
    animFrontStill.setRepeated(true);
    
    final Animation<Frame> animBackStill = new AnimationImpl<Frame>();
    animBackStill.addFrame(new FrameImpl(backImage, 160000000, 0, 0, 32, 66));
    animBackStill.setRepeated(true);
    
    final Animation<Frame> animBack = new AnimationImpl<Frame>();
    animBack.addFrame(new FrameImpl(animBackImage, 160000000, 0, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000, 37, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000, 74, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000,111, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000,148, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000,185, 0, 36, 70));
    animBack.setRepeated(true);
    
    final Color4f white = new Color4f(1,1,1,1);
    final Color4f white_alpha = new Color4f(1,1,1,.5f);
    final Color4f red = new Color4f(1,0,0,1);
    final Color4f green = new Color4f(0,1,0,1);
    final Color4f blue = new Color4f(0,0,1,1);


    canvas.setGraphicsListener(new GraphicsListener() {
      float angle = 0;
      long start = System.nanoTime();
      long currTime = start;
      long count = 0;
      long fps = 0;
  
      Animation<Frame> walk = animFrontStill;
      Flip flip = Flip.NONE;
      int xOffset = 0;


      public void draw(View view, Graphics renderer) {
        long elapsedTime = System.nanoTime() - currTime;
        currTime += elapsedTime;
        
        animLeft.update(elapsedTime);
        animFront.update(elapsedTime);
        animBack.update(elapsedTime);


        renderer.setColor(white);


        // Background
        for(int x = 0; x <= 800; x+=grass.getWidth() * 2) {
          for(int y = 0; y <= 600; y+=grass.getHeight() * 2) {
            renderer.pushTransform();
            renderer.translate(x, y);
            renderer.drawImage(grass, grass.getWidth() * 2, grass.getHeight() * 2);
//            renderer.clearTransformation();
            renderer.popTransform();
          }
        }
  
        for(int x = 0; x <= 800; x+=wall.getWidth() * 2) {
          renderer.pushTransform();
          renderer.translate(x, 160);
          renderer.drawImage(wall, wall.getWidth() * 2, wall.getHeight() * 2);
//          renderer.clearTransformation();
          renderer.popTransform();
        }
        for(int x = 0; x <= 800; x+=wall.getWidth() * 2) {
          renderer.pushTransform();
          renderer.translate(x, 380);
          renderer.drawImage(wall, wall.getWidth() * 2, wall.getHeight() * 2);
//          renderer.clearTransformation();
          renderer.popTransform();
        }
  
        for(int y = -16; y <= 400; y+=16) { 
          renderer.pushTransform();
          renderer.translate(272, y);
          renderer.drawImage(wall, wall.getWidth() * 2, 30, 0, 0, wall.getWidth(), 15);
//          renderer.clearTransformation();
          renderer.popTransform();
        }
        renderer.pushTransform();
        renderer.translate(272, 400);
        renderer.drawImage(wall, wall.getWidth() * 2, wall.getHeight() * 2);
//        renderer.clearTransformation();
        renderer.popTransform();
        for(int y = -16; y <= 400; y+=16) { 
          renderer.pushTransform();
          renderer.translate(512, y);
          renderer.drawImage(wall, wall.getWidth() * 2, 30, 0, 0, wall.getWidth(), 15);
//          renderer.clearTransformation();
          renderer.popTransform();
        }
        renderer.pushTransform();
        renderer.translate(512, 400);
        renderer.drawImage(wall, wall.getWidth() * 2, wall.getHeight() * 2);
//        renderer.clearTransformation();
        renderer.popTransform();
      
        // Animation
        int animationX = 50;
        int animationY = 50;
        renderer.translate(animationX, animationY);
        renderer.drawText("Animation");
        renderer.translate(0, 20);
        animLeft.draw(renderer, 44, 68);
        renderer.translate(54, 0);
        animLeft.draw(renderer, 44, 68, Flip.VERTICAL);
        renderer.translate(54, 0);
        animFront.draw(renderer, 40, 70);
        renderer.translate(50, 0);
        animBack.draw(renderer, 36, 70);
        renderer.clearTransform();
        // Flipping
        int flipX = 300;
        int flipY = 50;
        renderer.translate(flipX, flipY);
        renderer.drawText("Flipping");
        renderer.translate(0, 20);
        animLeft.draw(renderer, 44, 68, Flip.NONE);
        renderer.translate(50, 0);
        animLeft.draw(renderer, 44, 68, Flip.VERTICAL);
        renderer.translate(50, 0);
        animLeft.draw(renderer, 44, 68, Flip.HORIZONTAL);
        renderer.translate(50, 0);
        animLeft.draw(renderer, 44, 68, Flip.BOTH);
        renderer.clearTransform();
    
        // Rotating
        int rotateX = 550;
        int rotateY = 50;
        angle += elapsedTime / 20000000f;
        renderer.translate(rotateX, rotateY);
        renderer.drawText("Rotating");
        renderer.translate(20 + animLeft.getWidth() / 2, 20 + animLeft.getHeight() / 2);
        renderer.rotate(angle);
        renderer.translate(-(animLeft.getWidth() / 2), -(animLeft.getHeight() / 2));
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight());
        renderer.clearTransform();
        
        // Coloring
        int colorX = 50;
        int colorY = 220;
        renderer.translate(colorX, colorY);
        renderer.drawText("Coloring");
        renderer.setColor(red);
        renderer.translate(0, 20);
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight());
        renderer.setColor(green);
        renderer.translate(50, 0);
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight());
        renderer.setColor(blue);
        renderer.translate(50, 0);
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight());
        renderer.setColor(white_alpha);
        renderer.translate(50, 0);
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight());
        renderer.clearTransform();


        // Sub-Imaging
        int subX = 300;
        int subY = 220;
        renderer.setColor(white);
        renderer.translate(subX, subY);
        renderer.drawText("Sub-Imaging");
        renderer.translate(0, 20);
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight() / 2, 0, 0, animLeft.getWidth(), animLeft.getHeight() / 2);
        renderer.translate(0, 42);
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight() / 2, 0, animLeft.getHeight() / 2, animLeft.getWidth(), animLeft.getHeight() / 2);
        renderer.translate(50, -42);
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight() / 4, 0, 0, animLeft.getWidth(), animLeft.getHeight() / 4);
        renderer.translate(0, 8 + (animLeft.getHeight() / 4));
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight() / 4, 0, animLeft.getHeight() / 4, animLeft.getWidth(), animLeft.getHeight() / 4);
        renderer.translate(0, 8 + (animLeft.getHeight() / 4));
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight() / 4, 0, animLeft.getHeight() / 4 * 2, animLeft.getWidth(), animLeft.getHeight() / 4);
        renderer.translate(0, 8 + (animLeft.getHeight() / 4));
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight() / 4, 0, animLeft.getHeight() / 4 * 3, animLeft.getWidth(), animLeft.getHeight() / 4);
        renderer.translate(50, - 24 - (animLeft.getHeight() / 4 * 3));
        animLeft.draw(renderer, animLeft.getWidth() / 2, animLeft.getHeight(), 0, 0, animLeft.getWidth() / 2, animLeft.getHeight());
        renderer.translate(30, 0);
        animLeft.draw(renderer, animLeft.getWidth() / 2, animLeft.getHeight(), animLeft.getWidth() / 2, 0, animLeft.getWidth() / 2, animLeft.getHeight());
        renderer.clearTransform();
      
        // Sizing
        int sizeX = 550;
        int sizeY = 220;
        renderer.translate(sizeX, sizeY);
        renderer.drawText("Sizing");
        renderer.translate(0, 20);
        animLeft.draw(renderer, animLeft.getWidth() * 2, animLeft.getHeight() * 2);
        renderer.translate(10 + animLeft.getWidth() * 2, 0);
        animLeft.draw(renderer, animLeft.getWidth(), animLeft.getHeight());
        renderer.translate(0, animLeft.getHeight() * 3 / 2);
        animLeft.draw(renderer, animLeft.getWidth() * 2, animLeft.getHeight() / 2);
        renderer.translate(10 + animLeft.getWidth(), -(animLeft.getHeight() * 3 / 2));
        animLeft.draw(renderer, animLeft.getWidth() / 2, animLeft.getHeight() / 2);
        renderer.translate(-(10 - animLeft.getWidth()), 0);
        animLeft.draw(renderer, animLeft.getWidth() / 2, animLeft.getHeight() * 2);
        renderer.clearTransform();
      
        if(up && !down) {
          posY -= (float)elapsedTime / 11000000;
          walk = animBack;
          flip = Flip.NONE;
          xOffset = 0;
        } else if(down && !up) {
          posY += (float)elapsedTime / 11000000;
          walk = animFront;
          flip = Flip.NONE;
          xOffset = 0;
        } else if(left && !right) {
          posX -= (float)elapsedTime / 10000000;
          walk = animLeft;
          flip = Flip.NONE;
          xOffset = 0;
        } else if(right && !left) {
          posX += (float)elapsedTime / 10000000;
          walk = animLeft;
          flip = Flip.VERTICAL;
          xOffset = 0;
        } else {
          if(walk == animLeft) {
            walk = animLeftStill; 
            if(flip == Flip.NONE) xOffset = 4;
            else xOffset = 8;
          }
          if(walk == animFront) {
            walk = animFrontStill; 
            xOffset = 3;
          }
          if(walk == animBack) {
            walk = animBackStill; 
            xOffset = 1;
          }
        }
        
        renderer.clearTransform();
        renderer.translate(posX + xOffset, posY);
        walk.draw(renderer, walk.getWidth(), walk.getHeight(), flip);
        
        renderer.setColor(red);
        renderer.clearTransform();
        renderer.translate(650, 580);
        renderer.drawText("FPS:" + fps);
        
        count++;
        if(currTime - start > 1000000000) {
          start = currTime;
          fps = count;
          count = 0;
          System.out.println(fps);
        }
      }


      public void init(View view, Graphics renderer) {
        view.setCamera(400, 300, 0);
        view.setSize(800, 600);
      }


      public void sizeChanged(GraphicsContext canvas, View view) {}
      
    });


  
    // Cleaning up
    System.gc();
    
    // Starting the rendering
    long lastVSyncChange = 0;
    while(true) {
      if(keyboard != null) {
        keyboard.poll();
      
        // End demo
        if(keyboard.isKeyDown(Key.Q) || keyboard.isKeyDown(Key.ESCAPE)) {
          canvas.dispose();
          System.exit(0);
        }  
        // VSync
        if(keyboard.isKeyDown(Key.S)) {
          long time = System.currentTimeMillis();
          if(time - lastVSyncChange > 1000) {
            canvas.setVSync(!canvas.getVSync());
            lastVSyncChange = time;
          }
        }
        
        // Character movement
        down = keyboard.isKeyDown(Key.DOWN);
        left = keyboard.isKeyDown(Key.LEFT);
        right = keyboard.isKeyDown(Key.RIGHT);
        up = keyboard.isKeyDown(Key.UP);
      }
      
      canvas.draw();
    }
  }

View Full Code Here

    demo.start(ServiceLoader.load(ch.blackspirit.graphics.CanvasFactory.class).iterator().next());
  }
  
  public void start(ch.blackspirit.graphics.CanvasFactory factory) throws IOException {
    ControllerEnvironment controllerEnv = ControllerEnvironment.getDefaultEnvironment();
    Keyboard keyboard = null;
    for(Controller controller: controllerEnv.getControllers()) {
      if(controller.getType() == Type.KEYBOARD) {
        keyboard = (Keyboard)controller;
        break;
      }
    }
    
    // Create a fullscreen realtime canvas using the current display mode.
    DisplayMode mode = factory.getDisplayMode(WIDTH, HEIGHT);
    if(mode != null) {
      canvas = factory.createRealtimeCanvasFullscreen(mode);
    } else {
      canvas = factory.createRealtimeCanvasFullscreen();
    }
    
    canvas.setVSync(true);
    canvas.addWindowListener(WindowListener.EXIT_ON_CLOSE);
    canvas.setWindowTitle("Image Demo");


    final Image campfire = canvas.getImageFactory().createImage(
        SceneDemo.class.getResource("/sprites/campfire.png"), false);
    final Image animLeftImage = canvas.getImageFactory().createImage(
        SceneDemo.class.getResource("/sprites/Crono - Walk (Left) 44x68.png"), false);
    final Image animFrontImage = canvas.getImageFactory().createImage(
        SceneDemo.class.getResource("/sprites/Crono - Walk (Front) 40x70.png"), false);
    final Image animBackImage = canvas.getImageFactory().createImage(
        SceneDemo.class.getResource("/sprites/Crono - Walk (Back) 36x70.png"), false);
    final Image leftImage = canvas.getImageFactory().createImage(
        SceneDemo.class.getResource("/sprites/Crono (Left).png"), false);
    final Image frontImage = canvas.getImageFactory().createImage(
        SceneDemo.class.getResource("/sprites/Crono (Front).png"), false);
    final Image backImage = canvas.getImageFactory().createImage(
        SceneDemo.class.getResource("/sprites/Crono (Back).png"), false);
    final Image grass = canvas.getImageFactory().createImage(
        SceneDemo.class.getResource("/sprites/grass.png"), false);
    
    final Image dark = canvas.getImageFactory().createImage(128, 128, true);
    final Image light = canvas.getImageFactory().createBufferedImage(128, 128, 
        BufferTypeUtil.getBest(canvas.getImageFactory(), true));
    
    ResourceManager rm = canvas.getResourceManager();
    rm.cacheImage(dark);
    rm.cacheImage(campfire);
    rm.cacheImage(animLeftImage);
    rm.cacheImage(animFrontImage);
    rm.cacheImage(animBackImage);
    rm.cacheImage(leftImage);
    rm.cacheImage(frontImage);
    rm.cacheImage(backImage);
    rm.cacheImage(grass);  
 
    final Animation<Frame> animLeft = new AnimationImpl<Frame>();
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000, 0, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000, 45, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000, 90, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000,135, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000,180, 0, 44, 68));
    animLeft.addFrame(new FrameImpl(animLeftImage, 160000000,225, 0, 44, 68));
    animLeft.setRepeated(true);


    final Animation<Frame> animFront = new AnimationImpl<Frame>();
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000, 0, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000, 41, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000, 82, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000,123, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000,164, 0, 40, 70));
    animFront.addFrame(new FrameImpl(animFrontImage, 160000000,205, 0, 40, 70));
    animFront.setRepeated(true);




    final Animation<Frame> animLeftStill = new AnimationImpl<Frame>();
    animLeftStill.addFrame(new FrameImpl(leftImage, 160000000, 0, 0, 28, 68));
    animLeftStill.setRepeated(true);
    
    final Animation<Frame> animFrontStill = new AnimationImpl<Frame>();
    animFrontStill.addFrame(new FrameImpl(frontImage, 160000000, 0, 0, 32, 70));
    animFrontStill.setRepeated(true);
    
    final Animation<Frame> animBackStill = new AnimationImpl<Frame>();
    animBackStill.addFrame(new FrameImpl(backImage, 160000000, 0, 0, 32, 66));
    animBackStill.setRepeated(true);


    final Animation<Frame> animBack = new AnimationImpl<Frame>();
    animBack.addFrame(new FrameImpl(animBackImage, 160000000, 0, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000, 37, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000, 74, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000,111, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000,148, 0, 36, 70));
    animBack.addFrame(new FrameImpl(animBackImage, 160000000,185, 0, 36, 70));
    animBack.setRepeated(true);


    final Animation<Frame> animFire = new AnimationImpl<Frame>();
    animFire.addFrame(new FrameImpl(campfire, 120000000,1, 1, 64, 80));
    animFire.addFrame(new FrameImpl(campfire, 120000000, 66, 1, 64, 80));
    animFire.addFrame(new FrameImpl(campfire, 120000000, 131, 1, 64, 80));
    animFire.addFrame(new FrameImpl(campfire, 120000000,196, 1, 64, 80));
    animFire.setRepeated(true);


    final Color4f white = new Color4f(1,1,1,1);
    final Color4f red = new Color4f(1,0,0,1);
        
    ColorGradientFactory gradientFactory = new ColorGradientFactory();
    gradientFactory.addSourcePoint(light.getWidth() / 2, light.getHeight() / 2, light.getWidth() / 2f * .9f, new Color4f(0,0,0,0));
    gradientFactory.setBaseColor(new Color4f(1,1,1,1));
    gradientFactory.drawGradient(light);
  
    GraphicsContext imageContext = canvas.createImageGraphicsContext(dark);
    walk = animFrontStill;
    
    // Draw the light shine
    imageContext.setGraphicsListener(new GraphicsListener() {
      public void draw(View view, Graphics graphics) {
        view.setCamera(-400+posX, -300+posY, 0);
        graphics.setClearColor(new Color4f(.0f,.0f,.0f, .98f));
        graphics.clear();
        drawLight(graphics, walk, light, posX + xOffset, posY, lightShineRandom3);
        drawLight(graphics, animFire, light, 150 - animFire.getWidth()/2, 100 - animFire.getHeight()/2, lightShineRandom1);
        drawLight(graphics, animFire, light, 650 - animFire.getWidth()/2, 100 - animFire.getHeight()/2, lightShineRandom2);
        drawLight(graphics, animFire, light, 150 - animFire.getWidth()/2, 450 - animFire.getHeight()/2, lightShineRandom3);
        drawLight(graphics, animFire, light, 650 - animFire.getWidth()/2, 450 - animFire.getHeight()/2, lightShineRandom4);
      }
      public void init(View view, Graphics renderer) {
        view.setCamera(0, 0, 0);
        view.setSize(1024, 1024);
      }
      public void sizeChanged(GraphicsContext graphicsContext, View view) {}
    });
    
    canvas.setGraphicsListener(new GraphicsListener() {
      // Variables for fire simulation
      Random random = new Random();
      long lightShineTime = 0;


      long start = System.nanoTime();
      long currTime = start;
      long count = 0;
      long fps = 0;
  
      Flip flip = Flip.NONE;
      float angle = 0;


      public void draw(View view, Graphics renderer) {
        long elapsedTime = System.nanoTime() - currTime;
        currTime += elapsedTime;
        lightShineTime += elapsedTime;
  
        angle += elapsedTime / 20000000f;


        // Walking
        if(up && !down) {
          posY -= (float)elapsedTime / 11000000;
          walk = animBack;
          flip = Flip.NONE;
          xOffset = 0;
        } else if(down && !up) {
          posY += (float)elapsedTime / 11000000;
          walk = animFront;
          flip = Flip.NONE;
          xOffset = 0;
        } else if(left && !right) {
          posX -= (float)elapsedTime / 10000000;
          walk = animLeft;
          flip = Flip.NONE;
          xOffset = 0;
        } else if(right && !left) {
          posX += (float)elapsedTime / 10000000;
          walk = animLeft;
          flip = Flip.VERTICAL;
          xOffset = 0;
        } else {
          if(walk == animLeft) {
            walk = animLeftStill; 
            if(flip == Flip.NONE) xOffset = 4;
            else xOffset = 8;
          }
          if(walk == animFront) {
            walk = animFrontStill; 
            xOffset = 3;
          }
          if(walk == animBack) {
            walk = animBackStill; 
            xOffset = 1;
          }
        }
        
        view.setCamera(posX, posY, 0);
        
        // update animation
        animLeft.update(elapsedTime);
        animFront.update(elapsedTime);
        animBack.update(elapsedTime);
        animFire.update(elapsedTime);


        renderer.setColor(white);


        long gleft = (long)posX -400 - grass.getWidth()*2;
        gleft = gleft - (gleft % (grass.getWidth()*2));
        
        long gtop = (long)posY -300 - grass.getHeight()*2;
        gtop = gtop - (gtop % (grass.getHeight()*2));


        for(long x = gleft; x <= gleft + 800 + grass.getWidth()*2; x+=grass.getWidth() * 2) {
          for(long y = gtop; y <= gtop + 600 + grass.getHeight()*2; y+=grass.getHeight() * 2) { 
            renderer.translate(x, y);
            renderer.drawImage(grass, grass.getWidth() * 2, grass.getHeight() * 2);
            renderer.clearTransform();
          }
        }


        renderer.translate(posX + xOffset, posY);
        walk.draw(renderer, walk.getWidth(), walk.getHeight(), flip);
        renderer.clearTransform();


        // Fires
        drawFire(renderer, animFire, light, 150, 100, lightShineRandom1);
        drawFire(renderer, animFire, light, 650, 100, lightShineRandom2);
        drawFire(renderer, animFire, light, 150, 450, lightShineRandom3);
        drawFire(renderer, animFire, light, 650, 450, lightShineRandom4);


        // Draw darkness
        renderer.clearTransform();
        renderer.translate(posX-400, posY-300);
        renderer.drawImage(dark, 1024, 1024);
        
        renderer.setColor(white);
        renderer.clearTransform();
        renderer.translate(posX-400+50, posY-300+50);
        renderer.drawText("Scene Demo");


        // draw frames per second
        renderer.setColor(red);
        renderer.clearTransform();
        renderer.translate(posX-400+650, posY-300+580);
        renderer.drawText("FPS:" + fps);
              
        // calculate frames per second every second
        count++;
        if(currTime - start > 1000000000) {
          start = currTime;
          fps = count;
          count = 0;
          System.out.println(fps);
        }
        
        // Simulate flickering of light
        if(lightShineTime > 120000000) {
          lightShineRandom1 = random.nextInt(10);
          lightShineRandom2 = random.nextInt(10);
          lightShineRandom3 = random.nextInt(10);
          lightShineRandom4 = random.nextInt(10);
          lightShineTime = 0;
        }


      }


      public void init(View view, Graphics renderer) {
        view.setCamera(400, 300, 0);
        view.setSize(800, 600);
      }
      public void sizeChanged(GraphicsContext graphicsContext, View view) {  }
    });
    
    // Cleaning up
    System.gc();
    
    long lastVSyncChange = 0;
    while(true) {
      if(keyboard != null) {
        keyboard.poll();
      
        // End demo
        if(keyboard.isKeyDown(Key.Q) || keyboard.isKeyDown(Key.ESCAPE)) {
          canvas.dispose();
          System.exit(0);
        }
        // VSync
        if(keyboard.isKeyDown(Key.S)) {
          long time = System.currentTimeMillis();
          if(time - lastVSyncChange > 1000) {
            canvas.setVSync(!canvas.getVSync());
            lastVSyncChange = time;
          }
        }
        
        // Character movement
        down = keyboard.isKeyDown(Key.DOWN);
        left = keyboard.isKeyDown(Key.LEFT);
        right = keyboard.isKeyDown(Key.RIGHT);
        up = keyboard.isKeyDown(Key.UP);
      }


      imageContext.draw();
      canvas.draw();
    }

View Full Code Here

    demo.start();
  }
  
  public void start() throws IOException, InterruptedException {
    ControllerEnvironment controllerEnv = ControllerEnvironment.getDefaultEnvironment();
    Keyboard keyboard = null;
    for(Controller controller: controllerEnv.getControllers()) {
      if(controller.getType() == Type.KEYBOARD) {
        keyboard = (Keyboard)controller;
        break;
      }
    }


    // Getting video to show
    JFileChooser filechooser = new JFileChooser();
    filechooser.setMultiSelectionEnabled(false);
    if(filechooser.showOpenDialog(null) != JFileChooser.APPROVE_OPTION) return;
    File file = filechooser.getSelectedFile();
    
    CanvasFactory factory = new ch.blackspirit.graphics.jogl.CanvasFactory();


    // Create a fullscreen realtime canvas using the current display mode.
    DisplayMode mode = factory.getDisplayMode(WIDTH, HEIGHT);
    if(mode != null) {
      canvas = factory.createRealtimeCanvasFullscreen(mode);
    } else {
      canvas = factory.createRealtimeCanvasFullscreen();
    }
    
//    canvas.setVSync(true);
    canvas.addWindowListener(WindowListener.EXIT_ON_CLOSE);
    canvas.setWindowTitle("Video Demo");


    // JMF just loads jmf.properties from classpath root (not working in Webstart)
    // JMFInitializer helps loading them from any URL 
    JMFInitializer.initJMF(this.getClass().getResource("jmf.properties"));
    
    try {
      // Registering FOBS JMF plugins
      String FFMPEG_VIDEO_NATIVE = "com.omnividea.media.codec.video.NativeDecoder"; 
        Codec videoNative = (Codec) Class.forName(FFMPEG_VIDEO_NATIVE).newInstance();
        PlugInManager.addPlugIn(FFMPEG_VIDEO_NATIVE,
                videoNative.getSupportedInputFormats(),
                videoNative.getSupportedOutputFormats(null),
                PlugInManager.CODEC);


        //
//        String FFMPEG_AUDIO_NATIVE = "com.omnividea.media.codec.audio.NativeDecoder";
//        Codec audioNative = (Codec) Class.forName(FFMPEG_AUDIO_NATIVE).newInstance();
//        PlugInManager.addPlugIn(FFMPEG_AUDIO_NATIVE,
//            audioNative.getSupportedInputFormats(),
//            audioNative.getSupportedOutputFormats(null),
//                PlugInManager.CODEC);


//        String FFMPEG_VIDEO = "com.omnividea.media.codec.video.JavaDecoder"; 
//        Codec video = (Codec) Class.forName(FFMPEG_VIDEO).newInstance();
//        PlugInManager.addPlugIn(FFMPEG_VIDEO,
//                video.getSupportedInputFormats(),
//                video.getSupportedOutputFormats(null),
//                PlugInManager.CODEC);


//      String FFMPEG_AUDIO = "com.omnividea.media.codec.audio.JavaDecoder";
//        Codec audio= (Codec) Class.forName(FFMPEG_AUDIO).newInstance();
//        PlugInManager.addPlugIn(FFMPEG_AUDIO,
//            audio.getSupportedInputFormats(),
//            audio.getSupportedOutputFormats(null),
//                PlugInManager.CODEC);


      String FFMPEG_DEMUX = "com.omnividea.media.parser.video.Parser"; 
      Demultiplexer demux = (Demultiplexer) Class.forName(FFMPEG_DEMUX).newInstance();
        PlugInManager.addPlugIn(FFMPEG_DEMUX,
            demux.getSupportedInputContentDescriptors(),
            null,
                PlugInManager.DEMULTIPLEXER);


        // Registering Sun MP3 plugin
//      String MP3 = "com.sun.media.codec.audio.mp3.JavaDecoder";
//        Codec mp3 = (Codec) Class.forName(MP3).newInstance();
//        PlugInManager.addPlugIn(MP3,
//                mp3.getSupportedInputFormats(),
//                mp3.getSupportedOutputFormats(null),
//                PlugInManager.CODEC);


        
    } catch (Exception e) {
        throw new RuntimeException("Error loading codecs", e);
    }
    
    // Creating video renderer
    final VideoRenderer videoRenderer = new VideoRenderer(canvas.getImageFactory());
    if(!videoRenderer.open(file.toURI().toURL())) System.exit(0);


    canvas.setGraphicsListener(new GraphicsListener() {
      long start = System.nanoTime();
      long currTime = start;
      long count = 0;
      long fps = 0;


      Color4f red = new Color4f(1,0,0,1);
      Color4f white = new Color4f(1,1,1,1);
      Image image = null;
      
      public void draw(View view, Graphics graphics) {
        long elapsedTime = System.nanoTime() - currTime;
        currTime += elapsedTime;


        graphics.clear();
        graphics.setColor(white);
        graphics.clearTransform();
        
        // Getting current video image
        if(videoRenderer.isUpdated()) {
          image = videoRenderer.getCurrentImage();
          image.updateCache();
        }


        float sizeFactor = (WIDTH / (float)sizeDivider) / (float)image.getWidth();


        // Position and rotate video image
        graphics.rotate(rotate);
        graphics.translate((WIDTH / 2) / (float)sizeDivider, image.getHeight() * sizeFactor / 2);
        
        // Drawing video image
        if(image != null) {
          graphics.drawImage(image, image.getWidth() * sizeFactor, image.getHeight() * sizeFactor);
        }
        
        // draw frames per second
        graphics.setColor(red);
        graphics.clearTransform();
        graphics.translate(-250, -280);
        graphics.drawText("FPS:" + fps);
              
        // calculate frames per second every second
        count++;
        if(currTime - start > 1000000000) {
          start = currTime;
          fps = count;
          count = 0;
          System.out.println(fps);
        }
      }


      public void init(View view, Graphics renderer) {
        view.setSize(800, 600);
      }


      public void sizeChanged(GraphicsContext canvas, View view) {}
    });
    
    // Start the video
    if(!videoRenderer.start()) System.exit(0);
    
    long lastVSyncChange = 0;
    while(true) {
      if(keyboard != null) {
        keyboard.poll();
      
        // End demo
        if(keyboard.isKeyDown(Key.Q) || keyboard.isKeyDown(Key.ESCAPE)) {
          canvas.dispose();
          System.exit(0);
        }
        // VSync
        if(keyboard.isKeyDown(Key.S)) {
          long time = System.currentTimeMillis();
          if(time - lastVSyncChange > 1000) {
            canvas.setVSync(!canvas.getVSync());
            lastVSyncChange = time;
          }
        }
        
        // Keys 1 - 5 influence scale (1 = Fullscreen)
        if(keyboard.isKeyDown(Key._1)) {
          sizeDivider = 1;
        }
        if(keyboard.isKeyDown(Key._2)) {
          sizeDivider = 1.5f;
        }
        if(keyboard.isKeyDown(Key._3)) {
          sizeDivider = 2;
        }
        if(keyboard.isKeyDown(Key._4)) {
          sizeDivider = 3;
        }
        if(keyboard.isKeyDown(Key._5)) {
          sizeDivider = 4;
        }
        
        // Rotate Video
        if(keyboard.isKeyDown(Key.LEFT)) {
          rotate -= 2;
        }
        if(keyboard.isKeyDown(Key.RIGHT)) {
          rotate += 2;
        }
      }
      
      // On some systems vsync blocks video decoding, so we give it some time, this is a dirty workaround

View Full Code Here

    PrimitiveDemo demo = new PrimitiveDemo();
    demo.start();
  }
  private void start() {
    ControllerEnvironment controllerEnv = ControllerEnvironment.getDefaultEnvironment();
    Keyboard keyboard = null;
    for(Controller controller: controllerEnv.getControllers()) {
      if(controller.getType() == Type.KEYBOARD) {
        keyboard = (Keyboard)controller;
        break;
      }
    }


    CanvasFactory factory = ServiceLoader.load(ch.blackspirit.graphics.CanvasFactory.class).iterator().next();


    // Create a fullscreen realtime canvas using the current display mode.
    DisplayMode mode = factory.getDisplayMode(800, 600);
    if(mode != null) {
      canvas = factory.createRealtimeCanvasFullscreen(mode);
    } else {
      canvas = factory.createRealtimeCanvasFullscreen();
    }
    canvas.setVSync(true);
    canvas.addWindowListener(WindowListener.EXIT_ON_CLOSE);


    final Font font24 = new Font("SansSerif", Font.PLAIN, 24);
    final Font font16 = new Font("SansSerif", Font.PLAIN, 16);
  
    final Color4f white = new Color4f(1,1,1,1);
    final Color4f red = new Color4f(1,0,0,1);
        
    // Cleaning up
    System.gc();
    
    // Starting the rendering
    // Generate random set of triangles with random color
    final Random random = new Random();
    
    final int pointCount = 1000;
    final ArrayList<Vector2f> points = new ArrayList<Vector2f>();


    final int lineCount = 200;
    final ArrayList<Line> lines = new ArrayList<Line>();
    final Line[] lineA = new Line[lineCount];


    final int triangleCount = 100;
    final ArrayList<Triangle> triangles = new ArrayList<Triangle>(triangleCount);
    final Triangle[] triangleA = new Triangle[triangleCount];
    
    canvas.setGraphicsListener(new GraphicsListener() {
      long start = System.nanoTime();
      long currTime = start;
      long count = 0;
      long fps = 0;


      int alphaC = 0;


      public void draw(View view, Graphics renderer) {
        long elapsedTime = System.nanoTime() - currTime;
        currTime += elapsedTime;


        renderer.clear();


        renderer.clearTransform();
        renderer.setFont(font24);
        renderer.setColor(white);
        renderer.translate(-50, -50);
        renderer.drawText("Primitive Demo");


        // Random Points
        float randomPointsX1 = 50;
        float randomPointsY1 = 130;
        float randomPointsX2 = 250;
        float randomPointsY2 = 230;
        renderer.setFont(font16);
        renderer.clearTransform();
        renderer.translate(-randomPointsX1, -randomPointsY1 + 30);
        renderer.drawText("" + pointCount + " Random Points");
        renderer.clearTransform();
        float randomPointsWidth = randomPointsX2 - randomPointsX1;
        float randomPointsHeight = randomPointsY2 - randomPointsY1;
        Vector2f point;
        if(points.size() == pointCount) {
          point = points.remove(0);
        } else {
          point = new Vector2f();
        }
        points.add(point);
        point.x = random.nextFloat() * randomPointsWidth + randomPointsX1;
        point.y = random.nextFloat() * randomPointsHeight + randomPointsY1;
        
        for(int i = 0; i < points.size(); i++) {
          Vector2f p = points.get(i);
          renderer.drawPoint(p.x, p.y);
        }
        
        // Random Lines
        float randomLinesX1 = 50;
        float randomLinesY1 = 330;
        float randomLinesX2 = 250;
        float randomLinesY2 = 530;
        renderer.setFont(font16);
        renderer.clearTransform();
        renderer.translate(-randomLinesX1, -randomLinesY1 + 30);
        renderer.setColor(white);
        renderer.drawText("" + lineCount + " Random Lines");
        renderer.clearTransform();
        float randomLinesWidth = randomLinesX2 - randomLinesX1;
        float randomLinesHeight = randomLinesY2 - randomLinesY1;
        Line line;
        Color4f lineColor = null;
        if(lines.size() == lineCount) {
          line = lines.remove(0);
          lineColor = line.getColor(0);
        } else {
          line = new Line();
          lineColor = new Color4f();
          line.setColor(0, lineColor);
          line.setColor(1, lineColor);
        }
        lines.add(line);
        for(int i = 0; i < 2; i++) {
          line.getPoint(i).x = random.nextFloat() * randomLinesWidth + randomLinesX1;
          line.getPoint(i).y = random.nextFloat() * randomLinesHeight + randomLinesY1;
        }
        float linealpha = 1;
        if(alphaC == 5) linealpha = random.nextFloat();
        lineColor.set(random.nextFloat(), random.nextFloat(), random.nextFloat(), linealpha);


        lines.toArray(lineA);
        renderer.drawLines(lineA, true);
        
        // Random Triangles
        float randomTriangleX1 = 300;
        float randomTriangleY1 = 130;
        float randomTriangleX2 = 700;
        float randomTriangleY2 = 530;
        float randomTriangleWidth = randomTriangleX2 - randomTriangleX1;
        float randomTriangleHeight = randomTriangleY2 - randomTriangleY1;
        // Update random triangles
        alphaC++;
        Triangle triangle = null;
        Color4f triangleColor = null;
        if(triangles.size() == triangleCount) {
          triangle = triangles.remove(0);
          triangleColor = triangle.getColor(0);
        } else {
          triangle = new Triangle();
          triangleColor = new Color4f();
          triangle.setColor(0, triangleColor);
          triangle.setColor(1, triangleColor);
          triangle.setColor(2, triangleColor);
        }
        float alpha = 1;
        if(alphaC == 5){
          alpha = random.nextFloat();
          alphaC = 0;
        }
        triangleColor.set(random.nextFloat(), random.nextFloat(), random.nextFloat(), alpha);
        for(int i = 0; i < 3; i++) {
          triangle.getPoint(i).x = random.nextFloat() * randomTriangleWidth + randomTriangleX1;
          triangle.getPoint(i).y = random.nextFloat() * randomTriangleHeight + randomTriangleY1;
        }
        triangles.add(triangle);
        
        // Triangles
        renderer.setColor(white);


        renderer.setFont(font16);
        renderer.translate(-randomTriangleX1, -randomTriangleY1 + 30);
        renderer.drawText("" + triangleCount + " Random Triangles");
        
        renderer.clearTransform();
        
        triangles.toArray(triangleA);
        renderer.fillTriangles(triangleA, true);
        
        renderer.setColor(red);
        renderer.clearTransform();
        renderer.translate(-650, -580);
        renderer.drawText("FPS:" + fps);


        // calculate frames per second every second
        count++;
        if(currTime - start > 1000000000) {
          start = currTime;
          fps = count;
          count = 0;
          System.out.println(fps);
        }
      }


      public void init(View view, Graphics renderer) {
        view.setSize(800, 600);
        view.setCamera(400, 300, 0);
      }
      public void sizeChanged(GraphicsContext graphicsContext, View view) {}
    });
    
    long lastVSyncChange = 0;
    while(true) {
      if(keyboard != null) {
        keyboard.poll();
      
        // End demo
        if(keyboard.isKeyDown(Key.Q) || keyboard.isKeyDown(Key.ESCAPE)) {
          canvas.dispose();
          System.exit(0);
        }
        // VSync
        if(keyboard.isKeyDown(Key.S)) {
          long time = System.currentTimeMillis();
          if(time - lastVSyncChange > 1000) {
            canvas.setVSync(!canvas.getVSync());
            lastVSyncChange = time;
          }

View Full Code Here

    demo.start(ServiceLoader.load(ch.blackspirit.graphics.CanvasFactory.class).iterator().next());
  }
  
  public void start(CanvasFactory factory) throws IOException {
    ControllerEnvironment controllerEnv = ControllerEnvironment.getDefaultEnvironment();
    Keyboard keyboard = null;
    for(Controller controller: controllerEnv.getControllers()) {
      if(controller.getType() == Type.KEYBOARD) {
        keyboard = (Keyboard)controller;
        break;
      }
    }


    // Create a fullscreen realtime canvas using the current display mode.
    canvas = factory.createRealtimeCanvasFullscreen();


    canvas.setVSync(true);
    canvas.addWindowListener(WindowListener.EXIT_ON_CLOSE);
    canvas.setWindowTitle("Image Render Demo");
    
    final Image animLeftImage = canvas.getImageFactory().createImage(
        ModeChangeDemo.class.getResource("/sprites/Crono - Walk (Left) 44x68.png"), false);
    
    final Shape circle = ShapeFactory.createCircle(30, 25);
    final Shape circularArc = ShapeFactory.createCircularArc(30, -135, 135, 25);
    final Shape ellipse = ShapeFactory.createEllipse(75, 25, 25);
    final Shape ellipsoidalArc = ShapeFactory.createEllipsoidalArc(75, 25, 45, 315, 25);
    final Shape roundedRectangle = ShapeFactory.createRoundedRectangle(75, 40, 15);
    final Shape rectangle = ShapeFactory.createRectangle(75, 25);


    final Shape bscircle = ShapeFactory.createCircle(30, 25);


    List<Vector2f> rectOut = new ArrayList<Vector2f>();
    rectOut.add(new Vector2f(40, 10));
    rectOut.add(new Vector2f(-40, 10));
    rectOut.add(new Vector2f(-40, -10));
    rectOut.add(new Vector2f(40, -10));
    List<Vector2f> rectIn = new ArrayList<Vector2f>();
    rectIn.add(new Vector2f(20, 5));
    rectIn.add(new Vector2f(-20, 5));
    rectIn.add(new Vector2f(-20, -5));
    rectIn.add(new Vector2f(20, -5));
    List<List<Vector2f>> rectIns = new ArrayList<List<Vector2f>>();
    rectIns.add(rectIn);
    final Shape emptyRectangle = ShapeCreator.create(rectOut, rectIns);
    
    List<Vector2f> special1Outline = ShapeOutlineFactory.createRoundedRectangle(50, 40, 10, 3);
    List<Vector2f> special1Cutout1 = ShapeOutlineFactory.createRoundedRectangle(20, 30, 5, 3);


    List<List<Vector2f>> special1Cutouts = new ArrayList<List<Vector2f>>(2);
    special1Cutouts.add(special1Cutout1);
    
    final Shape manual1 = ShapeCreator.create(special1Outline, special1Cutouts);


    List<Vector2f> special2Outline = ShapeOutlineFactory.createCircle(30);
    List<Vector2f> special2Cutout1 = ShapeOutlineFactory.createCircle(10, 10);
    List<Vector2f> special2Cutout2 = ShapeOutlineFactory.createCircle(10, 10);
    for(Vector2f p: special2Cutout1) {
      p.x -= 15;
    }
    for(Vector2f p: special2Cutout2) {
      p.x += 15;
    }
    List<List<Vector2f>> special2Cutouts = new ArrayList<List<Vector2f>>(2);
    special2Cutouts.add(special2Cutout1);
    special2Cutouts.add(special2Cutout2);
    
    final Shape manual2 = ShapeCreator.create(special2Outline, special2Cutouts);


    
    final Image gradient = canvas.getImageFactory().createBufferedImage(256, 256, 
        BufferTypeUtil.getBest(canvas.getImageFactory(), true));
    
    final Color4f white = new Color4f(1,1,1,1);
    final Color4f red = new Color4f(1,0,0,1);
        
    ColorGradientFactory gradientFactory = new ColorGradientFactory();
    gradientFactory.addSourceSegment(50, 0, 50, 255, 150, new Color4f(1, 0, 0, 1));
    gradientFactory.addSourceSegment(205, 0, 205, 255,150, new Color4f(0, 0, 1, 1));
    gradientFactory.drawGradient(gradient);


    final Font fontNormal = new Font("SansSerif", Font.PLAIN, 24);
    final Font fontSmall = new Font("SansSerif", Font.PLAIN, 16);
    
    System.out.println("starting demo");
    canvas.setGraphicsListener(new GraphicsListener() {
      long start = System.nanoTime();
      long currTime = start;
      long count = 0;
      long fps = 0;
  
      float angle = 0;


      public void draw(View view, Graphics renderer) {
        long elapsedTime = System.nanoTime() - currTime;
        currTime += elapsedTime;
  
        angle += elapsedTime / 20000000f;
        TextureMapper.mapTexture(roundedRectangle, gradient, 128, 128, angle, 2f);
        TextureMapper.mapTexture(bscircle, animLeftImage, 80, 30, angle, 1);


        renderer.clear();
        
        renderer.setColor(white);


        renderer.translate(50, 50);
        renderer.setFont(fontNormal);
        renderer.drawText("Shape Demo");


        renderer.setFont(fontSmall);
        renderer.clearTransform();
        renderer.translate(100, 100);
        renderer.drawText("Common Shapes");
        
        renderer.clearTransform();
        renderer.translate(100, 150);
        rectangle.fillArea(renderer, false, false);
        renderer.translate(100, 0);
        roundedRectangle.fillArea(renderer, false, false);
        renderer.translate(100, 0);
        circle.fillArea(renderer, false, false);
        renderer.translate(100, 0);
        circularArc.fillArea(renderer, false, false);
        renderer.translate(100, 0);
        ellipse.fillArea(renderer, false, false);
        renderer.translate(100, 0);
        ellipsoidalArc.fillArea(renderer, false, false);


        renderer.clearTransform();
        renderer.translate(100, 230);
        renderer.drawTriangles(rectangle.getTriangles(), false);
        renderer.translate(100, 0);
        renderer.drawTriangles(roundedRectangle.getTriangles(), false);
        renderer.translate(100, 0);
        renderer.drawTriangles(circle.getTriangles(), false);
        renderer.translate(100, 0);
        renderer.drawTriangles(circularArc.getTriangles(), false);
        renderer.translate(100, 0);
        renderer.drawTriangles(ellipse.getTriangles(), false);
        renderer.translate(100, 0);
        renderer.drawTriangles(ellipsoidalArc.getTriangles(), false);
        
        renderer.clearTransform();
        renderer.translate(100, 350);
        renderer.drawText("Manually Created Shapes");


        renderer.clearTransform();
        renderer.translate(100, 400);
        emptyRectangle.fillArea(renderer, false, false);
        renderer.translate(100, 0);
        manual1.fillArea(renderer, false, false);
        renderer.translate(100, 0);
        manual2.fillArea(renderer, false, false);


        renderer.clearTransform();
        renderer.translate(100, 480);
        renderer.drawTriangles(emptyRectangle.getTriangles(), false);
        renderer.translate(100, 0);
        renderer.drawTriangles(manual1.getTriangles(), false);
        renderer.translate(100, 0);
        renderer.drawTriangles(manual2.getTriangles(), false);


        renderer.clearTransform();
        renderer.translate(500, 350);
        renderer.drawText("Shape Texturing");


        renderer.clearTransform();
        renderer.translate(500, 400);
        bscircle.fillArea(renderer, false, true);
        renderer.translate(100, 0);
        roundedRectangle.fillArea(renderer, false, true);
    
        // draw frames per second
        renderer.setColor(red);
        renderer.clearTransform();
        renderer.translate(650, 580);
        renderer.drawText("FPS:" + fps);
        
        // calculate frames per second every second
        count++;
        if(currTime - start > 1000000000) {
          start = currTime;
          fps = count;
          count = 0;
          System.out.println(fps);
        }
        
      }


      public void init(View view, Graphics renderer) {
        System.out.println("init");
        view.setCamera(400, 300, 0);
        view.setSize(800, 600);
        gradient.updateCache();
      }
      public void sizeChanged(GraphicsContext graphicsContext, View view) {  }
      
    });
  
    // Cleaning up
    System.gc();
    
    long lastVSyncChange = 0;
    while(true) {
      if(keyboard != null) {
        keyboard.poll();
      
        // End demo
        if(keyboard.isKeyDown(Key.Q) || keyboard.isKeyDown(Key.ESCAPE)) {
          canvas.dispose();
          System.exit(0);
        }
        // VSync
        if(keyboard.isKeyDown(Key.S)) {
          long time = System.currentTimeMillis();
          if(time - lastVSyncChange > 1000) {
            canvas.setVSync(!canvas.getVSync());
            lastVSyncChange = time;
          }

View Full Code Here

   * @throws IOException 
   * @throws InterruptedException 
   */
  public static void main(String[] args) throws IOException, InterruptedException {
    ControllerEnvironment controllerEnv = ControllerEnvironment.getDefaultEnvironment();
    Keyboard keyboard = null;
    for(Controller controller: controllerEnv.getControllers()) {
      if(controller.getType() == Type.KEYBOARD) {
        keyboard = (Keyboard)controller;
        break;
      }
    }


    final RealtimeCanvas canvas = ServiceLoader.load(ch.blackspirit.graphics.CanvasFactory.class).iterator().next()
        .createRealtimeCanvasWindow(800, 600);
    
    canvas.addWindowListener(WindowListener.EXIT_ON_CLOSE);
    canvas.setWindowTitle("Particle Demo");
    
    final Image image = canvas.getImageFactory().createImage(
        ParticleDemo.class.getResource("/ch/blackspirit/graphics/particle/particle.png"), false);
    canvas.getResourceManager().cacheImage(image);


    // Setup fire particle system
    final ParticleSystem<Particle> fireSystem = new ParticleSystem<Particle>(Particle.class);
    fireSystem.setImage(image);
    
    ParticleProducer<Particle> producer = new ParticleProducer<Particle>();
    producer.setIntervalMin(40);
    producer.setIntervalMax(40);
    producer.setCountMin(15);
    producer.setCountMax(15);
    
    Emitter<Particle> emitter = new Emitter<Particle>(producer);
    Initializer<Particle> initializer = new Initializer<Particle>();
    initializer.setSpeedMin(5);
    initializer.setSpeedMax(10);
    initializer.setSizeMin(40);
    initializer.setSizeMax(50);
    initializer.setAngleMin(-180f);
    initializer.setAngleMax(180f);
    initializer.setLifeMin(300);
    initializer.setLifeMax(2500);
    initializer.setXOffsetMin(-10);
    initializer.setXOffsetMax(10);
    initializer.setYOffsetMin(0);
    initializer.setYOffsetMax(0);
    initializer.setDistanceMax(10);
    initializer.setDistanceMin(0);
    emitter.addInitializer(initializer);
    fireSystem.addEmitter(emitter);
    
    ForceUpdater<Particle> force = new ForceUpdater<Particle>();
    force.setGravity(-.4f);
    fireSystem.addUpdater(force);
    
    fireSystem.addUpdater(new PhysicsUpdater<Particle>());
    
    PropertyUpdater<Particle> property = new PropertyUpdater<Particle>();
    property.setGrowthFactor(.2f);
    property.getR().addPoint(.6f, .02f);
    property.getG().addPoint(.6f, .02f);
    property.getB().addPoint(.6f, .01f);
    property.getA().addPoint(.6f, 1f);


    property.getR().addPoint(.7f, .3f);
    property.getG().addPoint(.7f, .15f);
    property.getB().addPoint(.7f, .05f);
    property.getA().addPoint(.7f, 1f);


    property.getR().addPoint(.8f, .2f);
    property.getG().addPoint(.8f, 0);
    property.getB().addPoint(.8f, 0);
    property.getA().addPoint(.8f, 1);


    property.getR().addPoint(1f, 0f);
    property.getG().addPoint(1f, 0);
    property.getB().addPoint(1f, 0);
    property.getA().addPoint(1f, 0);
    fireSystem.addUpdater(property);


    // Setup spring particle system
    final ParticleSystem<Particle> springSystem = new ParticleSystem<Particle>(Particle.class);
    springSystem.setImage(image);
    
    ParticleProducer<Particle> springProducer1 = new ParticleProducer<Particle>();
    springProducer1.setIntervalMin(3);
    springProducer1.setIntervalMax(3);
    springProducer1.setCountMin(1);
    springProducer1.setCountMax(1);
    
    Emitter<Particle> springEmitter1 = new Emitter<Particle>(springProducer1);
    Initializer<Particle> springInitializer1 = new Initializer<Particle>();
    springEmitter1.setPosition(-10, 0);
    springInitializer1.setSpeedMin(110);
    springInitializer1.setSpeedMax(150);
    springInitializer1.setSizeMin(3);
    springInitializer1.setSizeMax(5);
    springInitializer1.setAngleMin(9f);
    springInitializer1.setAngleMax(10f);
    springInitializer1.setLifeMin(2000);
    springInitializer1.setLifeMax(3000);
    springInitializer1.setXOffsetMin(0);
    springInitializer1.setXOffsetMax(0);
    springInitializer1.setYOffsetMin(0);
    springInitializer1.setYOffsetMax(0);
    springInitializer1.setDistanceMax(2);
    springInitializer1.setDistanceMin(0);
    springEmitter1.addInitializer(springInitializer1);
    springSystem.addEmitter(springEmitter1);


    ParticleProducer<Particle> springProducer2 = new ParticleProducer<Particle>();
    springProducer2.setIntervalMin(3);
    springProducer2.setIntervalMax(3);
    springProducer2.setCountMin(1);
    springProducer2.setCountMax(1);


    Emitter<Particle> springEmitter2 = new Emitter<Particle>(springProducer2);
    Initializer<Particle> springInitializer2 = new Initializer<Particle>();
    springEmitter2.setPosition(10, 0);
    springInitializer2.setSpeedMin(110);
    springInitializer2.setSpeedMax(150);
    springInitializer2.setSizeMin(3);
    springInitializer2.setSizeMax(5);
    springInitializer2.setAngleMin(-10f);
    springInitializer2.setAngleMax(-9f);
    springInitializer2.setLifeMin(2000);
    springInitializer2.setLifeMax(3000);
    springInitializer2.setXOffsetMin(0);
    springInitializer2.setXOffsetMax(0);
    springInitializer2.setYOffsetMin(0);
    springInitializer2.setYOffsetMax(0);
    springInitializer2.setDistanceMax(2);
    springInitializer2.setDistanceMin(0);
    springEmitter2.addInitializer(springInitializer2);
    springSystem.addEmitter(springEmitter2);


    ForceUpdater<Particle> springForce = new ForceUpdater<Particle>();
    springForce.setGravity(.9f);
    springSystem.addUpdater(springForce);
    
    springSystem.addUpdater(new PhysicsUpdater<Particle>());
    
    PropertyUpdater<Particle> springProperty = new PropertyUpdater<Particle>();
    springProperty.setGrowthFactor(1f);
    springProperty.getR().addPoint(0f, .35f);
    springProperty.getG().addPoint(0f, .35f);
    springProperty.getB().addPoint(0f, .4f);
    springProperty.getA().addPoint(0f, 1f);


    springProperty.getR().addPoint(.7f, .35f);
    springProperty.getG().addPoint(.7f, .35f);
    springProperty.getB().addPoint(.7f, .4f);
    springProperty.getA().addPoint(.7f, 1);


    springProperty.getR().addPoint(1f, .9f);
    springProperty.getG().addPoint(1f, .9f);
    springProperty.getB().addPoint(1f, .9f);
    springProperty.getA().addPoint(1f, 0);
    springSystem.addUpdater(springProperty);


    final Color4f white = new Color4f(1,1,1,1);
    final Color4f red = new Color4f(1,0,0,1);
    
    canvas.setGraphicsListener(new GraphicsListener() {
      long start = System.currentTimeMillis();
      long currTime = start;
      long count = 0;
      long fps = 0;
      
      public void draw(View view, Graphics renderer) {
        long elapsedTime = System.currentTimeMillis() - currTime;
        currTime += elapsedTime;


        renderer.setDrawingMode(DrawingMode.ALPHA_ADD);
        renderer.setColor(white);


        renderer.clear();
        renderer.clearTransform();
        renderer.translate(200, 350);
        fireSystem.draw(renderer);


        renderer.clearTransform();
        renderer.translate(600, 350);
        springSystem.draw(renderer);
        
        renderer.clearTransform();
        renderer.translate(50, 50);
        renderer.drawText("Particle Demo");
        
        renderer.clearTransform();
        renderer.translate(100, 500);
        renderer.drawText("Fire particles: " + fireSystem.getParticleCount());


        renderer.clearTransform();
        renderer.translate(500, 500);
        renderer.drawText("Spring particles: " + springSystem.getParticleCount());


        // draw frames per second
        renderer.setColor(red);
        renderer.clearTransform();
        renderer.translate(650, 580);
        renderer.drawText("FPS: " + fps);
              
        // calculate frames per second every second
        count++;
        if(currTime - start > 1000) {
          start = currTime;
          fps = count;
          count = 0;
          System.out.println(fps + " fps");
        }
      }
      public void init(View view, Graphics renderer) {
        view.setCamera(400, 300,0);
        view.setSize(800, 600);
      }
      public void sizeChanged(GraphicsContext graphicsContext, View view) {}
    });
    
    fireSystem.start();
    springSystem.start();


    long currTime = System.currentTimeMillis();
    long lastVSyncChange = 0;
    while(true) {
      if(keyboard != null) {
        keyboard.poll();
      
        // End demo
        if(keyboard.isKeyDown(Key.Q) || keyboard.isKeyDown(Key.ESCAPE)) {
          canvas.dispose();
          System.exit(0);
        }
        // VSync
        if(keyboard.isKeyDown(Key.S)) {
          long time = System.currentTimeMillis();
          if(time - lastVSyncChange > 1000) {
            canvas.setVSync(!canvas.getVSync());
            lastVSyncChange = time;
          }

View Full Code Here

TOP

Related Classes of net.java.games.input.Keyboard

ch.blackspirit.graphics.demo.CaptureDemo

ch.blackspirit.graphics.demo.ImageDemo

ch.blackspirit.graphics.demo.ParticleDemo

ch.blackspirit.graphics.demo.PrimitiveDemo

ch.blackspirit.graphics.demo.SceneDemo

ch.blackspirit.graphics.demo.ShapeDemo

ch.blackspirit.graphics.demo.VideoDemo

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.