TestCameraMotionPath2.scala.txt

package jme3test.animation

/*
 * Copyright (c) 2009-2012 jMonkeyEngine
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
 *   may be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

import com.jme3.animation.LoopMode
import com.jme3.app.SimpleApplication
import com.jme3.cinematic.MotionPath
import com.jme3.cinematic.MotionPathListener
import com.jme3.cinematic.events.MotionEvent
import com.jme3.font.BitmapText
import com.jme3.input.ChaseCamera
import com.jme3.input.KeyInput
import com.jme3.input.controls.ActionListener
import com.jme3.input.controls.KeyTrigger
import com.jme3.light.DirectionalLight
import com.jme3.material.Material
import com.jme3.math.ColorRGBA
import com.jme3.math.Spline.SplineType
import com.jme3.math.Vector3f
import com.jme3.scene.CameraNode
import com.jme3.scene.Geometry
import com.jme3.scene.Spatial
import com.jme3.scene.control.CameraControl.ControlDirection
import com.jme3.scene.shape.Box
import com.jme3.system.AppSettings
import org.cef.{CefClient, CefApp}
import org.cef.browser.{CefBrowserFactory, CefRenderer, CefBrowser}
import java.awt.{Color, Rectangle}
import java.nio.{Buffer, ByteBuffer}
import com.jme3.asset.plugins.{ClasspathLocator, FileLocator}
import java.io.File
import com.jme3.asset.AssetLocator
import tachyon.Users
import com.jme3.texture.Texture
import com.jme3.renderer.Renderer
import java.util
import com.jme3.util.Screenshots
import java.awt.image.BufferedImage

object TestCameraMotionPath2 {

  def main(args: Array[String]) {
    val app: TestCameraMotionPath2 = new TestCameraMotionPath2
    app.setShowSettings(false)
    val settings: AppSettings = new AppSettings(true)
    settings.put("Width", new Integer(1920))
    settings.put("Height", new Integer(1120))
    settings.put("Title", "Shape")
    settings.put("VSync", Boolean.box(true))
    settings.put("Samples", new Integer(4))
    app.setSettings(settings)
    app.start
  }
}

class TestCameraMotionPath2 extends SimpleApplication {

  var cefApp: CefApp = null
  var cefClient: CefClient = null
  var cefBrowser: CefBrowser = null

  //@volatile
  //var byteArray: Array[Byte] = new Array[Byte](800 * 600 * 4)
  //val newBuffer = ByteBuffer.allocateDirect(800 * 600 * 4)


  override def destroy = {
    cefApp.dispose
  }

  @volatile
  var screenBuffer: ByteBuffer = null

  def chromium = {
    cefApp = CefApp.getInstance
    cefClient = cefApp.createClient
    val cefRenderer: CefRenderer = new CefRenderer {
      def render {
      }


      def onPaint(popup: Boolean, dirtyRects: Array[Rectangle], buffer: ByteBuffer, width: Int, height: Int) {

        // Copy the data across
        var pos: Int = 0
        if (screenBuffer==null) screenBuffer = ByteBuffer.allocateDirect(width * height * 4)
        for (rect <- dirtyRects) {
          for (y <- rect.y until (rect.y + rect.height); x <- rect.x until (rect.x + rect.width)) {
            pos = x * 4 + (y * width * 4)
            screenBuffer.put(pos, buffer.get(pos + 2))
            screenBuffer.put(pos + 1, buffer.get(pos + 1))
            screenBuffer.put(pos + 2, buffer.get(pos))
            screenBuffer.put(pos + 3, buffer.get(pos + 3))
          }
        }

        texture.getImage.setData(0, screenBuffer)
      }

    }
    val startURL = "http://www.newscientist.com/"
    val isTransparent = true
    cefBrowser = cefClient.createBrowser(startURL, isTransparent, CefBrowserFactory.RenderType.RENDER_BYTE_BUFFER, null, 800, 600, cefRenderer)
  }

  def simpleInitApp {
    //assetManager.registerLocator("assets", classOf[FileLocator]) // By default the assets directory is used

    createScene
    cam.setLocation(new Vector3f(8.4399185f, 11.189463f, 14.267577f))
    camNode = new CameraNode("Motion cam", cam)
    camNode.setControlDir(ControlDirection.SpatialToCamera)
    camNode.setEnabled(false)
    path = new MotionPath
    path.setCycle(true)
    path.addWayPoint(new Vector3f(20, 3, 0))
    path.addWayPoint(new Vector3f(0, 3, 20))
    path.addWayPoint(new Vector3f(-20, 3, 0))
    path.addWayPoint(new Vector3f(0, 3, -20))
    path.setCurveTension(0.83f)
    path.enableDebugShape(assetManager, rootNode)
    cameraMotionControl = new MotionEvent(camNode, path)
    cameraMotionControl.setLoopMode(LoopMode.Loop)
    cameraMotionControl.setLookAt(teapot.getWorldTranslation, Vector3f.UNIT_Y)
    cameraMotionControl.setDirectionType(MotionEvent.Direction.LookAt)
    rootNode.attachChild(camNode)
    guiFont = assetManager.loadFont("Interface/Fonts/Default.fnt")
    val wayPointsText: BitmapText = new BitmapText(guiFont, false)
    wayPointsText.setSize(guiFont.getCharSet.getRenderedSize)
    guiNode.attachChild(wayPointsText)
    path.addListener(new MotionPathListener {
      def onWayPointReach(control: MotionEvent, wayPointIndex: Int) {
        if (path.getNbWayPoints == wayPointIndex + 1) {
          wayPointsText.setText(control.getSpatial.getName + " Finish!!! ")
        }
        else {
          wayPointsText.setText(control.getSpatial.getName + " Reached way point " + wayPointIndex)
        }
        wayPointsText.setLocalTranslation((cam.getWidth - wayPointsText.getLineWidth) / 2, cam.getHeight, 0)
      }
    })
    flyCam.setEnabled(false)
    chaser = new ChaseCamera(cam, teapot)
    chaser.registerWithInput(inputManager)
    chaser.setSmoothMotion(true)
    chaser.setMaxDistance(50)
    chaser.setDefaultDistance(50)
    initInputs

    chromium
  }

  var paintableTexture: PaintableTexture = null
  var byteBuffer: ByteBuffer = null
  var texture: Texture = null

  private def createScene {
    val mat: Material = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md")
    mat.setFloat("Shininess", 1f)
    mat.setBoolean("UseMaterialColors", true)
    mat.setColor("Ambient", ColorRGBA.Black)
    mat.setColor("Diffuse", ColorRGBA.DarkGray)
    mat.setColor("Specular", ColorRGBA.White.mult(0.6f))
    val matSoil: Material = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md")
    matSoil.setBoolean("UseMaterialColors", true)
    matSoil.setColor("Ambient", ColorRGBA.Gray)
    matSoil.setColor("Diffuse", ColorRGBA.Gray)
    matSoil.setColor("Specular", ColorRGBA.Black)
    teapot = assetManager.loadModel("Models/Teapot/Teapot.obj")
    teapot.setLocalScale(3)
    teapot.setMaterial(mat)
    rootNode.attachChild(teapot)
    val soil: Geometry = new Geometry("soil", new Box(new Vector3f(0, -1.0f, 0), 50, 1, 50))
    soil.setMaterial(matSoil)
    rootNode.attachChild(soil)
    val light: DirectionalLight = new DirectionalLight
    light.setDirection(new Vector3f(0, -1, 0).normalizeLocal)
    light.setColor(ColorRGBA.White.mult(1.5f))
    rootNode.addLight(light)

    val b: Box = new Box(10, 10, 10)
    val geom: Geometry = new Geometry("Box", b)
    val material: Material = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md")

    paintableTexture = new PaintableTexture(800, 600)
    paintableTexture.setBackground(Color.white)
    texture = paintableTexture.getTexture()
    byteBuffer = texture.getImage.getData(0)
    material.setTexture("ColorMap", texture)

    // To update the texture, call update with false as parameter and call node.updateRenderState()
    // Make sure to call setRefreshNeeded() on the image

    //val t: Texture = assetManager.loadTexture("Interface/Logo/Monkey.jpg")
    //material.setTexture("ColorMap", assetManager.loadTexture("Interface/Logo/Monkey.jpg"))

    geom.setMaterial(material)
    rootNode.attachChild(geom)
  }

  @volatile
  var time: Float = 0.0f

  override def simpleUpdate(tpf: Float) = {
    time = time + tpf
  }

  private def initInputs {
    inputManager.addMapping("display_hidePath", new KeyTrigger(KeyInput.KEY_P))
    inputManager.addMapping("SwitchPathInterpolation", new KeyTrigger(KeyInput.KEY_I))
    inputManager.addMapping("tensionUp", new KeyTrigger(KeyInput.KEY_U))
    inputManager.addMapping("tensionDown", new KeyTrigger(KeyInput.KEY_J))
    inputManager.addMapping("play_stop", new KeyTrigger(KeyInput.KEY_SPACE))
    val acl: ActionListener = new ActionListener {
      def onAction(name: String, keyPressed: Boolean, tpf: Float) {
        if ((name == "display_hidePath") && keyPressed) {
          if (active) {
            active = false
            path.disableDebugShape
          }
          else {
            active = true
            path.enableDebugShape(assetManager, rootNode)
          }
        }
        if ((name == "play_stop") && keyPressed) {
          if (playing) {
            playing = false
            cameraMotionControl.stop
            chaser.setEnabled(true)
            camNode.setEnabled(false)
          }
          else {
            playing = true
            chaser.setEnabled(false)
            camNode.setEnabled(true)
            cameraMotionControl.play
          }
        }
        if ((name == "SwitchPathInterpolation") && keyPressed) {
          if (path.getPathSplineType eq SplineType.CatmullRom) {
            path.setPathSplineType(SplineType.Linear)
          }
          else {
            path.setPathSplineType(SplineType.CatmullRom)
          }
        }
        if ((name == "tensionUp") && keyPressed) {
          path.setCurveTension(path.getCurveTension + 0.1f)
          System.err.println("Tension : " + path.getCurveTension)
        }
        if ((name == "tensionDown") && keyPressed) {
          path.setCurveTension(path.getCurveTension - 0.1f)
          System.err.println("Tension : " + path.getCurveTension)
        }
      }
    }
    inputManager.addListener(acl, "display_hidePath", "play_stop", "SwitchPathInterpolation", "tensionUp", "tensionDown")
  }

  private var teapot: Spatial = null
  private var active: Boolean = true
  private var playing: Boolean = false
  private var path: MotionPath = null
  private var cameraMotionControl: MotionEvent = null
  private var chaser: ChaseCamera = null
  private var camNode: CameraNode = null
}