Exemplo n.º 1
0
 public static float getYRotationAngle(GVRSceneObject rotatingObject, GVRCameraRig targetObject) {
   return (float)
       Math.toDegrees(
           Math.atan2(
               targetObject.getTransform().getPositionX()
                   - rotatingObject.getTransform().getPositionX(),
               targetObject.getTransform().getPositionZ()
                   - rotatingObject.getTransform().getPositionZ()));
 }
Exemplo n.º 2
0
 public static double distance(GVRSceneObject object, GVRCameraRig gvrCameraRig) {
   return Math.sqrt(
       Math.pow(
               object.getTransform().getPositionX() - gvrCameraRig.getTransform().getPositionX(),
               2)
           + Math.pow(
               object.getTransform().getPositionY() - gvrCameraRig.getTransform().getPositionY(),
               2)
           + Math.pow(
               object.getTransform().getPositionZ() - gvrCameraRig.getTransform().getPositionZ(),
               2));
 }
Exemplo n.º 3
0
 private void createTouchpad() {
   touchPad =
       new GVRSceneObject(
           getGVRContext(),
           getGVRContext().loadMesh(new GVRAndroidResource(getGVRContext(), (R.drawable.gear_vr))),
           getGVRContext()
               .loadTexture(new GVRAndroidResource(getGVRContext(), R.drawable.gear_vr_texture)));
   touchPad.getTransform().setPositionZ(-4f);
   touchPad.getTransform().setPositionY(0.1f);
   touchPad.getTransform().setPositionX(-0.895f);
   touchPad.getTransform().rotateByAxis(-90, 0, 1, 0);
   touchPad.getTransform().setScale(SCALE_OBJECT, SCALE_OBJECT, SCALE_OBJECT);
   touchPad.getRenderData().setRenderingOrder(RenderingOrder.ORDER_RENDERING_GAMEPAD);
 }
  /* Returns true if subtree contains renderables */
  protected boolean scanTree(GVRSceneObject node) {
    boolean containsRenderable = node.getRenderData() != null;

    for (GVRSceneObject child : node.getChildren()) {
      containsRenderable |= scanTree(child);
    }

    // Find channel Id
    int channelId = animation.findChannel(node.getName());
    if (channelId != -1 && containsRenderable) {
      animatedNodes.add(new AnimationItem(node, channelId));
    }

    return containsRenderable;
  }
Exemplo n.º 5
0
  public static float[] calculatePointBetweenTwoObjects(
      GVRSceneObject object, GVRCameraRig gvrCameraRig, float desiredDistance) {
    float[] point = new float[3];
    float ratio = desiredDistance / (float) distance(object, gvrCameraRig);
    point[0] =
        (1 - ratio) * gvrCameraRig.getTransform().getPositionX()
            + (ratio) * object.getTransform().getPositionX();
    point[1] =
        (1 - ratio) * gvrCameraRig.getTransform().getPositionY()
            + (ratio) * object.getTransform().getPositionY();
    point[2] =
        (1 - ratio) * gvrCameraRig.getTransform().getPositionZ()
            + (ratio) * object.getTransform().getPositionZ();

    return point;
  }
Exemplo n.º 6
0
  public static float distance(GVRSceneObject obj1, GVRSceneObject obj2) {

    Vector3d v1 =
        new Vector3d(
            obj1.getTransform().getPositionX(),
            obj1.getTransform().getPositionY(),
            obj1.getTransform().getPositionZ());

    Vector3d v2 =
        new Vector3d(
            obj2.getTransform().getPositionX(),
            obj2.getTransform().getPositionY(),
            obj2.getTransform().getPositionZ());

    return (float) v1.distance(v2);
  }
Exemplo n.º 7
0
  @Override
  public void onInit(GVRContext gvrContext) {
    this.gvrContext = gvrContext;
    random = new Random();
    mainScene = gvrContext.getNextMainScene();
    shaderManager = new CustomShaderManager(gvrContext);
    mainScene.getMainCameraRig().getLeftCamera().setBackgroundColor(1.0f, 1.0f, 1.0f, 1.0f);
    mainScene.getMainCameraRig().getRightCamera().setBackgroundColor(1.0f, 1.0f, 1.0f, 1.0f);

    addSurroundings(gvrContext, mainScene);

    // set up the input manager for the main scene
    GVRInputManager inputManager = gvrContext.getInputManager();

    inputManager.addCursorControllerListener(this);

    for (GVRCursorController cursor : inputManager.getCursorControllers()) {
      onCursorControllerAdded(cursor);
    }

    // set the default text
    setTextOnMainThread(SELECT_TEXT);

    GVRViewSceneObject text =
        new GVRViewSceneObject(gvrContext, textView, gvrContext.createQuad(30.0f, 20.0f));
    text.getTransform().setPosition(0.0f, 17.0f, -35.0f);
    text.getRenderData().setRenderingOrder(10002);

    mainScene.addSceneObject(text);

    GVRSceneObject cube1 = new Cube(gvrContext, "Cube 1", shaderManager);
    cube1.getTransform().setPosition(0.0f, 1.0f, -10.0f);
    mainScene.addSceneObject(cube1);
    // add the sensor to the cube
    addSensor(cube1);

    GVRSceneObject cube2 = new Cube(gvrContext, "Cube 2", shaderManager);
    cube2.getTransform().setPosition(0.0f, 1.0f, -12.0f);
    cube2.getTransform().rotateByAxisWithPivot(-15.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
    cube2.getTransform().setRotation(1.0f, 0.0f, 0.0f, 0.0f);
    mainScene.addSceneObject(cube2);
    // add the sensor to the cube
    addSensor(cube2);

    GVRSceneObject cube3 = new Cube(gvrContext, "Cube 3", shaderManager);
    cube3.getTransform().setPosition(0.0f, 1.0f, -15.0f);
    cube3.getTransform().rotateByAxisWithPivot(15.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
    cube3.getTransform().rotateByAxisWithPivot(15.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
    cube3.getTransform().setRotation(1.0f, 0.0f, 0.0f, 0.0f);
    mainScene.addSceneObject(cube3);
    // add the sensor to the cube
    addSensor(cube3);
  }
  @Override
  public void onInit(GVRContext gvrContext) throws IOException {

    mAnimationEngine = gvrContext.getAnimationEngine();

    mMainScene =
        gvrContext.getNextMainScene(
            new Runnable() {

              @Override
              public void run() {
                for (GVRAnimation animation : mAnimations) {
                  animation.start(mAnimationEngine);
                }
                mAnimations = null;
              }
            });

    // Apply frustum culling
    mMainScene.setFrustumCulling(true);

    GVRCameraRig mainCameraRig = mMainScene.getMainCameraRig();
    mainCameraRig.getLeftCamera().setBackgroundColor(Color.BLACK);
    mainCameraRig.getRightCamera().setBackgroundColor(Color.BLACK);
    mainCameraRig.getTransform().setPosition(0.0f, 0.0f, 0.0f);

    // Model with texture
    GVRSceneObject astroBoyModel = gvrContext.getAssimpModel("astro_boy.dae");

    // Model with color
    GVRSceneObject benchModel = gvrContext.getAssimpModel("bench.dae");

    ModelPosition astroBoyModelPosition = new ModelPosition();

    astroBoyModelPosition.setPosition(0.0f, -0.4f, -0.5f);

    astroBoyModel.getTransform().setScale(3, 3, 3);

    astroBoyModel
        .getTransform()
        .setPosition(astroBoyModelPosition.x, astroBoyModelPosition.y, astroBoyModelPosition.z);
    astroBoyModel.getTransform().setRotationByAxis(180.0f, 0.0f, 1.0f, 0.0f);

    ModelPosition benchModelPosition = new ModelPosition();

    benchModelPosition.setPosition(0.0f, -4.0f, -30.0f);

    benchModel
        .getTransform()
        .setPosition(benchModelPosition.x, benchModelPosition.y, benchModelPosition.z);
    benchModel.getTransform().setRotationByAxis(180.0f, 0.0f, 1.0f, 0.0f);

    mMainScene.addSceneObject(astroBoyModel);
    mMainScene.addSceneObject(benchModel);

    rotateModel(astroBoyModel, 10f, astroBoyModelPosition);
  }
Exemplo n.º 9
0
  @Override
  public void onCursorControllerAdded(final GVRCursorController controller) {
    GVRSceneObject sceneObject = new GVRSceneObject(gvrContext);
    Future<GVRTexture> texture =
        gvrContext.loadFutureTexture(new GVRAndroidResource(gvrContext, R.raw.earthmap1k));

    GVRMaterial material = new GVRMaterial(gvrContext, shaderManager.getShaderId());

    // stay away from the darker colors for the cursor
    float r = random.nextFloat() / 2.0f + 0.5f;
    float g = random.nextFloat() / 2.0f + 0.5f;
    float b = random.nextFloat() / 2.0f + 0.5f;

    material.setVec3(CustomShaderManager.COLOR_KEY, r, g, b);
    material.setTexture(CustomShaderManager.TEXTURE_KEY, texture);
    material.setMainTexture(texture);
    Future<GVRMesh> futureCursorMesh =
        gvrContext.loadFutureMesh(new GVRAndroidResource(gvrContext, R.raw.cursor));

    GVRRenderData cursorRenderData = new GVRRenderData(gvrContext);
    cursorRenderData.setMesh(futureCursorMesh);
    cursorRenderData.setMaterial(material);
    sceneObject.attachRenderData(cursorRenderData);

    mainScene.addSceneObject(sceneObject);
    controller.setSceneObject(sceneObject);

    // set the initial cursor position
    controller.setPosition(
        INITIAL_CURSOR_POSITION[0], INITIAL_CURSOR_POSITION[1], INITIAL_CURSOR_POSITION[2]);

    // set the min cursor depth
    controller.setNearDepth(NEAR_DEPTH);

    // set the max cursor depth
    controller.setFarDepth(FAR_DEPTH);
  }
Exemplo n.º 10
0
  // The assets for the Cubemap are taken from the Samsung Developers website:
  // http://www.samsung.com/us/samsungdeveloperconnection/developer-resources/
  // gear-vr/apps-and-games/exercise-2-creating-the-splash-scene.html
  private void addSurroundings(GVRContext gvrContext, GVRScene scene) {
    FutureWrapper<GVRMesh> futureQuadMesh =
        new FutureWrapper<GVRMesh>(gvrContext.createQuad(CUBE_WIDTH, CUBE_WIDTH));
    Future<GVRTexture> futureCubemapTexture =
        gvrContext.loadFutureCubemapTexture(new GVRAndroidResource(gvrContext, R.raw.earth));

    GVRMaterial cubemapMaterial = new GVRMaterial(gvrContext, GVRMaterial.GVRShaderType.Cubemap.ID);
    cubemapMaterial.setMainTexture(futureCubemapTexture);

    // surrounding cube
    GVRSceneObject frontFace = new GVRSceneObject(gvrContext, futureQuadMesh, futureCubemapTexture);
    frontFace.getRenderData().setMaterial(cubemapMaterial);
    frontFace.setName("front");
    scene.addSceneObject(frontFace);
    frontFace.getTransform().setPosition(0.0f, 0.0f, -CUBE_WIDTH * 0.5f);

    GVRSceneObject backFace = new GVRSceneObject(gvrContext, futureQuadMesh, futureCubemapTexture);
    backFace.getRenderData().setMaterial(cubemapMaterial);
    backFace.setName("back");
    scene.addSceneObject(backFace);
    backFace.getTransform().setPosition(0.0f, 0.0f, CUBE_WIDTH * 0.5f);
    backFace.getTransform().rotateByAxis(180.0f, 0.0f, 1.0f, 0.0f);

    GVRSceneObject leftFace = new GVRSceneObject(gvrContext, futureQuadMesh, futureCubemapTexture);
    leftFace.getRenderData().setMaterial(cubemapMaterial);
    leftFace.setName("left");
    scene.addSceneObject(leftFace);
    leftFace.getTransform().setPosition(-CUBE_WIDTH * 0.5f, 0.0f, 0.0f);
    leftFace.getTransform().rotateByAxis(90.0f, 0.0f, 1.0f, 0.0f);

    GVRSceneObject rightFace = new GVRSceneObject(gvrContext, futureQuadMesh, futureCubemapTexture);
    rightFace.getRenderData().setMaterial(cubemapMaterial);
    rightFace.setName("right");
    scene.addSceneObject(rightFace);
    rightFace.getTransform().setPosition(CUBE_WIDTH * 0.5f, 0.0f, 0.0f);
    rightFace.getTransform().rotateByAxis(-90.0f, 0.0f, 1.0f, 0.0f);

    GVRSceneObject topFace = new GVRSceneObject(gvrContext, futureQuadMesh, futureCubemapTexture);
    topFace.getRenderData().setMaterial(cubemapMaterial);
    topFace.setName("top");
    scene.addSceneObject(topFace);
    topFace.getTransform().setPosition(0.0f, CUBE_WIDTH * 0.5f, 0.0f);
    topFace.getTransform().rotateByAxis(90.0f, 1.0f, 0.0f, 0.0f);

    GVRSceneObject bottomFace =
        new GVRSceneObject(gvrContext, futureQuadMesh, futureCubemapTexture);
    bottomFace.getRenderData().setMaterial(cubemapMaterial);
    bottomFace.setName("bottom");
    scene.addSceneObject(bottomFace);
    bottomFace.getTransform().setPosition(0.0f, -CUBE_WIDTH * 0.5f, 0.0f);
    bottomFace.getTransform().rotateByAxis(-90.0f, 1.0f, 0.0f, 0.0f);
  }
Exemplo n.º 11
0
    @Override
    public void onSensorEvent(SensorEvent event) {
      GVRSceneObject cursor = event.getCursorController().getSceneObject();

      int id = event.getCursorController().getId();
      // Safe to assume that the returned object is a cube
      Cube cube = (Cube) event.getObject();
      if (cursor == null || (selected != null && selectedCursorId != id)) {
        Log.d(TAG, "onSensorEvent Return null");
        return;
      }

      if (event.isActive() == false && selected != null && id == selectedCursorId) {
        cursor.removeChildObject(selected);
        selected
            .getTransform()
            .setPosition(
                +cursor.getTransform().getPositionX() + selected.getTransform().getPositionX(),
                +cursor.getTransform().getPositionY() + selected.getTransform().getPositionY(),
                +cursor.getTransform().getPositionZ() + selected.getTransform().getPositionZ());
        selected = null;
        selectedCursorId = -1;
      }

      if (event.isActive()) {
        if (cube.isColliding(cursor) && selected == null) {
          selected = cube;
          selectedCursorId = id;
          event
              .getObject()
              .getTransform()
              .setPosition(
                  -cursor.getTransform().getPositionX() + selected.getTransform().getPositionX(),
                  -cursor.getTransform().getPositionY() + selected.getTransform().getPositionY(),
                  -cursor.getTransform().getPositionZ() + selected.getTransform().getPositionZ());
          cursor.addChildObject(selected);

          cube.setGreen();
          setTextOnMainThread(MOVE_CUBE_TEXT);
        }
      } else if (event.isOver()) {
        if (cube.isColliding(cursor)) {
          cube.setRed();
          setTextOnMainThread(BUTTON_SELECT_TEXT);
        } else {
          cube.setGrey();
          setTextOnMainThread(SELECT_TEXT);
        }
      } else {
        cube.setGrey();
        setTextOnMainThread(SELECT_TEXT);
      }
    }
Exemplo n.º 12
0
 private void addSensor(GVRSceneObject sceneObject) {
   CubeSensor sensor = new CubeSensor(gvrContext);
   sceneObject.setSensor(sensor);
   sceneObject.getEventReceiver().addListener(sensor);
 }
Exemplo n.º 13
0
  @Override
  public void onInit(GVRContext gvrContext) {

    mGVRContext = gvrContext;

    mMetalOnlyShader = new MetalOnlyShader(mGVRContext);
    mDiffuseShader = new DiffuseShader(mGVRContext);
    mGlassShader = new GlassShader(mGVRContext);
    mReflectionShader = new ReflectionShader(mGVRContext);
    mPhongShader = new PhongShader(mGVRContext);

    mMetalShader2 = new MetalShader2(mGVRContext);
    mDiffuseShader2 = new DiffuseShader2(mGVRContext);
    mGlassShader2 = new GlassShader2(mGVRContext);
    mPhongShader2 = new PhongShader2(mGVRContext);
    mPhongShader3 = new PhongShader3(mGVRContext);

    GVRScene mainScene = mGVRContext.getNextMainScene();

    mainScene.getMainCameraRig().getLeftCamera().setBackgroundColor(1.0f, 1.0f, 1.0f, 1.0f);
    mainScene.getMainCameraRig().getRightCamera().setBackgroundColor(1.0f, 1.0f, 1.0f, 1.0f);

    try {
      GVRTexture env_tex = mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "env.jpg"));
      mReflectionMaterial = new GVRMaterial(mGVRContext, mReflectionShader.getShaderId());
      mReflectionMaterial.setVec4(ReflectionShader.COLOR_KEY, 1.0f, 1.0f, 1.0f, 1.0f);
      mReflectionMaterial.setFloat(ReflectionShader.RADIUS_KEY, 10.0f);
      mReflectionMaterial.setTexture(ReflectionShader.TEXTURE_KEY, env_tex);

      // ------------------------------------------------------ set
      // materials
      // watch
      mMetalMaterial = new GVRMaterial(mGVRContext, mMetalOnlyShader.getShaderId());
      mMetalMaterial.setVec4(MetalOnlyShader.COLOR_KEY, 1.7f, 1.4f, 1.0f, 1.0f);
      mMetalMaterial.setFloat(MetalOnlyShader.RADIUS_KEY, 10.0f);
      mMetalMaterial.setTexture(MetalOnlyShader.TEXTURE_KEY, env_tex);

      mGlassMaterial = new GVRMaterial(mGVRContext, mGlassShader.getShaderId());
      mGlassMaterial.setVec4(GlassShader.COLOR_KEY, 1.0f, 1.0f, 1.0f, 1.0f);
      mGlassMaterial.setFloat(MetalOnlyShader.RADIUS_KEY, 10.0f);
      mGlassMaterial.setTexture(GlassShader.TEXTURE_KEY, env_tex);

      GVRTexture board_tex =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "watch/board.jpg"));
      mDiffuseMaterial = new GVRMaterial(mGVRContext, mDiffuseShader.getShaderId());
      mDiffuseMaterial.setVec4(DiffuseShader.COLOR_KEY, 1.0f, 1.0f, 1.0f, 1.0f);
      mDiffuseMaterial.setTexture(DiffuseShader.TEXTURE_KEY, board_tex);

      // jar
      mPhongMaterial = new GVRMaterial(mGVRContext, mPhongShader.getShaderId());
      mPhongMaterial.setVec4(PhongShader.COLOR_KEY, 1.2f, 1.2f, 1.3f, 1.0f);
      mPhongMaterial.setFloat(PhongShader.RADIUS_KEY, 10.0f);
      mPhongMaterial.setTexture(PhongShader.TEXTURE_KEY, env_tex);

      // car
      GVRTexture car_body_tex =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "car/body.jpg"));
      mCarBodyMaterial = new GVRMaterial(mGVRContext, mPhongShader3.getShaderId());
      mCarBodyMaterial.setFloat(PhongShader3.RADIUS_KEY, 10.0f);
      mCarBodyMaterial.setTexture(PhongShader3.ENV_KEY, env_tex);
      mCarBodyMaterial.setTexture(PhongShader3.TEXTURE_KEY, car_body_tex);

      mCarWheelMaterial = new GVRMaterial(mGVRContext, mMetalShader2.getShaderId());
      mCarWheelMaterial.setVec4(MetalShader2.COLOR_KEY, 1.2f, 1.2f, 1.2f, 1.0f);
      mCarWheelMaterial.setFloat(MetalShader2.RADIUS_KEY, 10.0f);
      mCarWheelMaterial.setTexture(MetalShader2.TEXTURE_KEY, env_tex);

      mCarGlassMaterial = new GVRMaterial(mGVRContext, mGlassShader2.getShaderId());
      mCarGlassMaterial.setVec4(GlassShader2.COLOR_KEY, 1.0f, 1.0f, 1.0f, 1.0f);
      mCarGlassMaterial.setFloat(GlassShader2.RADIUS_KEY, 10.0f);
      mCarGlassMaterial.setTexture(GlassShader2.TEXTURE_KEY, env_tex);

      GVRTexture default_tex =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "car/default.bmp"));
      mCarTireMaterial = new GVRMaterial(mGVRContext, mDiffuseShader2.getShaderId());
      mCarTireMaterial.setVec4(DiffuseShader2.COLOR_KEY, 0.1f, 0.1f, 0.1f, 1.0f);
      mCarTireMaterial.setTexture(DiffuseShader2.TEXTURE_KEY, default_tex);

      GVRTexture back_tex =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "car/back.jpg"));
      mCarBackMaterial = new GVRMaterial(mGVRContext, mDiffuseShader2.getShaderId());
      mCarBackMaterial.setVec4(DiffuseShader2.COLOR_KEY, 1.0f, 1.0f, 1.0f, 1.0f);
      mCarBackMaterial.setTexture(DiffuseShader2.TEXTURE_KEY, back_tex);

      GVRTexture grill_tex =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "car/grill.jpg"));
      mCarGrillMaterial = new GVRMaterial(mGVRContext, mDiffuseShader2.getShaderId());
      mCarGrillMaterial.setVec4(DiffuseShader2.COLOR_KEY, 1.0f, 1.0f, 1.0f, 1.0f);
      mCarGrillMaterial.setTexture(DiffuseShader2.TEXTURE_KEY, grill_tex);

      mCarLightMaterial = new GVRMaterial(mGVRContext, mGlassShader2.getShaderId());
      mCarLightMaterial.setVec4(GlassShader2.COLOR_KEY, 2.5f, 2.5f, 2.5f, 1.0f);
      mCarLightMaterial.setFloat(GlassShader2.RADIUS_KEY, 10.0f);
      mCarLightMaterial.setTexture(GlassShader2.TEXTURE_KEY, env_tex);

      mCarInsideMaterial = new GVRMaterial(mGVRContext, mPhongShader2.getShaderId());
      mCarInsideMaterial.setVec4(PhongShader2.COLOR_KEY, 0.0f, 0.0f, 0.0f, 1.0f);
      mCarInsideMaterial.setFloat(PhongShader2.RADIUS_KEY, 10.0f);
      mCarInsideMaterial.setTexture(PhongShader2.TEXTURE_KEY, env_tex);

      // robot
      GVRTexture robot_head_tex =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "robot/head.jpg"));
      mRobotHeadMaterial = new GVRMaterial(mGVRContext, mPhongShader3.getShaderId());
      mRobotHeadMaterial.setFloat(PhongShader3.RADIUS_KEY, 10.0f);
      mRobotHeadMaterial.setTexture(PhongShader3.ENV_KEY, env_tex);
      mRobotHeadMaterial.setTexture(PhongShader3.TEXTURE_KEY, robot_head_tex);

      mRobotMetalMaterial = new GVRMaterial(mGVRContext, mMetalShader2.getShaderId());
      mRobotMetalMaterial.setVec4(MetalShader2.COLOR_KEY, 1.5f, 1.5f, 1.5f, 1.0f);
      mRobotMetalMaterial.setFloat(MetalShader2.RADIUS_KEY, 10.0f);
      mRobotMetalMaterial.setTexture(MetalShader2.TEXTURE_KEY, env_tex);

      mRobotBodyMaterial = new GVRMaterial(mGVRContext, mPhongShader2.getShaderId());
      mRobotBodyMaterial.setVec4(PhongShader2.COLOR_KEY, 1.0f, 1.0f, 1.0f, 1.0f);
      mRobotBodyMaterial.setFloat(PhongShader2.RADIUS_KEY, 10.0f);
      mRobotBodyMaterial.setTexture(PhongShader2.TEXTURE_KEY, env_tex);

      mRobotRubberMaterial = new GVRMaterial(mGVRContext, mDiffuseShader2.getShaderId());
      mRobotRubberMaterial.setVec4(DiffuseShader2.COLOR_KEY, 0.3f, 0.3f, 0.3f, 1.0f);
      mRobotRubberMaterial.setTexture(DiffuseShader2.TEXTURE_KEY, default_tex);

      // leaf
      GVRTexture leaf_box_tex =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "leaf/box.jpg"));
      mLeafBoxMaterial = new GVRMaterial(mGVRContext, mPhongShader3.getShaderId());
      mLeafBoxMaterial.setFloat(PhongShader3.RADIUS_KEY, 10.0f);
      mLeafBoxMaterial.setTexture(PhongShader3.ENV_KEY, env_tex);
      mLeafBoxMaterial.setTexture(PhongShader3.TEXTURE_KEY, leaf_box_tex);

      mLeafBodyMaterial = new GVRMaterial(mGVRContext, mMetalShader2.getShaderId());
      mLeafBodyMaterial.setVec4(MetalShader2.COLOR_KEY, 2.5f, 2.5f, 2.5f, 1.0f);
      mLeafBodyMaterial.setFloat(MetalShader2.RADIUS_KEY, 10.0f);
      mLeafBodyMaterial.setTexture(MetalShader2.TEXTURE_KEY, env_tex);

      // ------------------------------------------------------ set
      // objects

      for (int i = 0; i < THUMBNAIL_NUM; i++) Objects[i] = new GVRSceneObject(mGVRContext);

      // --------------watch

      GVRSceneObject obj1 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData1 = new GVRRenderData(mGVRContext);
      GVRMesh mesh1 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "watch/frame.obj"));
      renderData1.setMesh(mesh1);
      renderData1.setMaterial(mMetalMaterial);
      obj1.attachRenderData(renderData1);
      Objects[2].addChildObject(obj1);

      GVRSceneObject obj2 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData2 = new GVRRenderData(mGVRContext);
      GVRMesh mesh2 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "watch/board.obj"));
      renderData2.setMesh(mesh2);
      renderData2.setMaterial(mDiffuseMaterial);
      obj2.attachRenderData(renderData2);
      Objects[2].addChildObject(obj2);

      GVRSceneObject obj3 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData3 = new GVRRenderData(mGVRContext);
      GVRMesh mesh3 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "watch/glass.obj"));
      renderData3.setMesh(mesh3);
      renderData3.setMaterial(mGlassMaterial);
      obj3.attachRenderData(renderData3);

      obj3.getRenderData().setRenderingOrder(3000);
      Objects[2].addChildObject(obj3);

      Objects[2].getTransform().setPosition(0.0f, 0.0f, -EYE_TO_OBJECT);
      mainScene.addSceneObject(Objects[2]);

      // --------------jar

      GVRSceneObject obj5 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData5 = new GVRRenderData(mGVRContext);
      GVRMesh mesh5 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "jar/jar.obj"));
      renderData5.setMesh(mesh5);
      renderData5.setMaterial(mPhongMaterial);
      obj5.attachRenderData(renderData5);
      Objects[1].addChildObject(obj5);

      GVRSceneObject obj4 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData4 = new GVRRenderData(mGVRContext);
      GVRMesh mesh4 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "jar/edge.obj"));
      renderData4.setMesh(mesh4);
      renderData4.setMaterial(mMetalMaterial);
      obj4.attachRenderData(renderData4);
      obj4.getRenderData().setRenderingOrder(3000);
      Objects[1].addChildObject(obj4);

      Objects[1].getTransform().setPosition(0.0f, 0.0f, -EYE_TO_OBJECT);
      mainScene.addSceneObject(Objects[1]);

      // --------------car

      GVRSceneObject obj6 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData6 = new GVRRenderData(mGVRContext);
      GVRMesh mesh6 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "car/body.obj"));
      renderData6.setMesh(mesh6);
      renderData6.setMaterial(mCarBodyMaterial);
      obj6.attachRenderData(renderData6);
      obj6.getRenderData().setCullTest(false);
      Objects[3].addChildObject(obj6);

      GVRSceneObject obj9 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData9 = new GVRRenderData(mGVRContext);
      GVRMesh mesh9 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "car/tire.obj"));
      renderData9.setMesh(mesh9);
      renderData9.setMaterial(mCarTireMaterial);
      obj9.attachRenderData(renderData9);
      Objects[3].addChildObject(obj9);

      GVRSceneObject obj10 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData10 = new GVRRenderData(mGVRContext);
      GVRMesh mesh10 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "car/glass.obj"));
      renderData10.setMesh(mesh10);
      renderData10.setMaterial(mCarGlassMaterial);
      obj10.attachRenderData(renderData10);
      obj10.getRenderData().setCullTest(false);
      obj10.getRenderData().setRenderingOrder(3000);
      Objects[3].addChildObject(obj10);

      GVRSceneObject obj11 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData11 = new GVRRenderData(mGVRContext);
      GVRMesh mesh11 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "car/wheel.obj"));
      renderData11.setMesh(mesh11);
      renderData11.setMaterial(mCarWheelMaterial);
      obj11.attachRenderData(renderData11);
      Objects[3].addChildObject(obj11);

      GVRSceneObject obj12 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData12 = new GVRRenderData(mGVRContext);
      GVRMesh mesh12 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "car/back.obj"));
      renderData12.setMesh(mesh12);
      renderData12.setMaterial(mCarBackMaterial);
      obj12.attachRenderData(renderData12);
      Objects[3].addChildObject(obj12);

      GVRSceneObject obj13 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData13 = new GVRRenderData(mGVRContext);
      GVRMesh mesh13 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "car/grill.obj"));
      renderData13.setMesh(mesh13);
      renderData13.setMaterial(mCarGrillMaterial);
      obj13.attachRenderData(renderData13);
      obj10.getRenderData().setRenderingOrder(3000);
      Objects[3].addChildObject(obj13);

      GVRSceneObject obj14 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData14 = new GVRRenderData(mGVRContext);
      GVRMesh mesh14 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "car/glass2.obj"));
      renderData14.setMesh(mesh14);
      renderData14.setMaterial(mCarLightMaterial);
      obj14.attachRenderData(renderData14);
      obj14.getRenderData().setRenderingOrder(4000);
      Objects[3].addChildObject(obj14);

      GVRSceneObject obj19 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData19 = new GVRRenderData(mGVRContext);
      GVRMesh mesh19 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "car/inside.obj"));
      renderData19.setMesh(mesh19);
      renderData19.setMaterial(mCarInsideMaterial);
      obj19.attachRenderData(renderData19);
      Objects[3].addChildObject(obj19);

      Objects[3].getTransform().setPosition(0.0f, -2.0f, -EYE_TO_OBJECT - 3.0f);
      mainScene.addSceneObject(Objects[3]);

      // robot

      GVRSceneObject obj15 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData15 = new GVRRenderData(mGVRContext);
      GVRMesh mesh15 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "robot/body.obj"));
      renderData15.setMesh(mesh15);
      renderData15.setMaterial(mRobotBodyMaterial);
      obj15.attachRenderData(renderData15);
      Objects[4].addChildObject(obj15);

      GVRSceneObject obj16 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData16 = new GVRRenderData(mGVRContext);
      GVRMesh mesh16 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "robot/head.obj"));
      renderData16.setMesh(mesh16);
      renderData16.setMaterial(mRobotHeadMaterial);
      obj16.attachRenderData(renderData16);
      Objects[4].addChildObject(obj16);

      GVRSceneObject obj17 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData17 = new GVRRenderData(mGVRContext);
      GVRMesh mesh17 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "robot/metal.obj"));
      renderData17.setMesh(mesh17);
      renderData17.setMaterial(mRobotMetalMaterial);
      obj17.attachRenderData(renderData17);
      obj17.getRenderData().setRenderingOrder(3000);
      Objects[4].addChildObject(obj17);

      GVRSceneObject obj18 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData18 = new GVRRenderData(mGVRContext);
      GVRMesh mesh18 =
          mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "robot/rubber.obj"));
      renderData18.setMesh(mesh18);
      renderData18.setMaterial(mRobotRubberMaterial);
      obj18.attachRenderData(renderData18);
      Objects[4].addChildObject(obj18);

      Objects[4].getTransform().setPosition(0.0f, 0.0f, -EYE_TO_OBJECT);
      mainScene.addSceneObject(Objects[4]);

      // leaf

      GVRSceneObject obj20 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData20 = new GVRRenderData(mGVRContext);
      GVRMesh mesh20 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "leaf/leaf.obj"));
      renderData20.setMesh(mesh20);
      renderData20.setMaterial(mLeafBodyMaterial);
      obj20.attachRenderData(renderData20);
      Objects[0].addChildObject(obj20);

      GVRSceneObject obj21 = new GVRSceneObject(mGVRContext);
      GVRRenderData renderData21 = new GVRRenderData(mGVRContext);
      GVRMesh mesh21 = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "leaf/box.obj"));
      renderData21.setMesh(mesh21);
      renderData21.setMaterial(mLeafBoxMaterial);
      obj21.attachRenderData(renderData21);
      Objects[0].addChildObject(obj21);

      Objects[0].getTransform().setPosition(0.0f, 0.0f, -EYE_TO_OBJECT);
      mainScene.addSceneObject(Objects[0]);

      for (int I = 0; I < THUMBNAIL_NUM; I++)
        for (int i = 0; i < Objects[I].getChildrenCount(); i++)
          Objects[I].getChildByIndex(i).getRenderData().setRenderMask(0);
      // ------------------------------------------------------ set
      // thumbnails

      ThumbnailTextures[0] =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "leaf/leaf.jpg"));
      ThumbnailTextures[1] =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "jar/jar.png"));
      ThumbnailTextures[2] =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "watch/watch.png"));
      ThumbnailTextures[3] =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "car/car.bmp"));
      ThumbnailTextures[4] =
          mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "robot/robot.jpg"));

      ThumbnailTargetPosition[0][0] = -2.2f;
      ThumbnailTargetPosition[0][1] = 0.0f;
      ThumbnailTargetPosition[0][2] = -EYE_TO_OBJECT - 2.8f;
      ThumbnailTargetPosition[1][0] = -1.0f;
      ThumbnailTargetPosition[1][1] = 0.0f;
      ThumbnailTargetPosition[1][2] = -EYE_TO_OBJECT - 1.5f;
      ThumbnailTargetPosition[2][0] = 0.0f;
      ThumbnailTargetPosition[2][1] = 0.0f;
      ThumbnailTargetPosition[2][2] = -EYE_TO_OBJECT - 0.0f;
      ThumbnailTargetPosition[3][0] = 1.0f;
      ThumbnailTargetPosition[3][1] = 0.0f;
      ThumbnailTargetPosition[3][2] = -EYE_TO_OBJECT - 1.5f;
      ThumbnailTargetPosition[4][0] = 2.2f;
      ThumbnailTargetPosition[4][1] = 0.0f;
      ThumbnailTargetPosition[4][2] = -EYE_TO_OBJECT - 2.8f;

      for (int i = 0; i < THUMBNAIL_NUM; i++)
        for (int j = 0; j < 3; j++) ThumbnailCurrentPosition[i][j] = ThumbnailTargetPosition[i][j];
      for (int i = 0; i < THUMBNAIL_NUM; i++) ThumbnailTargetIndex[i] = i;

      ThumbnailOrder[0] = 10000;
      ThumbnailOrder[1] = 10001;
      ThumbnailOrder[2] = 10002;
      ThumbnailOrder[3] = 10001;
      ThumbnailOrder[4] = 10000;

      GVRMesh glass_mesh = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "glass.obj"));
      GVRMesh board_mesh = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "board.obj"));
      GVRMesh picks_mesh = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "pick.obj"));
      for (int i = 0; i < THUMBNAIL_NUM; i++) {
        ThumbnailObject[i] = new GVRSceneObject(mGVRContext);
        ThumbnailRotation[i] = new GVRSceneObject(mGVRContext);
        GVRSceneObject obj = new GVRSceneObject(mGVRContext);
        ThumbnailGlasses[i] = new GVRRenderData(mGVRContext);
        ThumbnailGlasses[i].setMesh(glass_mesh);
        ThumbnailGlasses[i].setMaterial(mReflectionMaterial);
        obj.attachRenderData(ThumbnailGlasses[i]);
        obj.getRenderData().setRenderingOrder(ThumbnailOrder[i]);
        ThumbnailRotation[i].addChildObject(obj);
        ThumbnailObject[i].addChildObject(ThumbnailRotation[i]);

        Thumbnails[i] = new GVRSceneObject(mGVRContext, board_mesh, ThumbnailTextures[i]);
        Thumbnails[i].getRenderData().setRenderingOrder(ThumbnailOrder[i] - 100);
        Thumbnails[i].getRenderData().setCullTest(false);
        Thumbnails[i].getTransform().setScale(1.0f, 1.2f, 1.0f);
        ThumbnailRotation[i].addChildObject(Thumbnails[i]);

        ThumbnailObject[i]
            .getTransform()
            .setPosition(
                ThumbnailTargetPosition[i][0],
                ThumbnailTargetPosition[i][1],
                ThumbnailTargetPosition[i][2]);
        mainScene.addSceneObject(ThumbnailObject[i]);

        GVREyePointeeHolder eyePointeeHolder = new GVREyePointeeHolder(gvrContext);
        GVRMeshEyePointee eyePointee = new GVRMeshEyePointee(gvrContext, picks_mesh);
        eyePointeeHolder.addPointee(eyePointee);
        ThumbnailObject[i].attachEyePointeeHolder(eyePointeeHolder);
      }

      GVRTexture m360 = mGVRContext.loadTexture(new GVRAndroidResource(mGVRContext, "env.jpg"));
      GVRMesh sphere = mGVRContext.loadMesh(new GVRAndroidResource(mGVRContext, "sphere.obj"));

      GVRSceneObject env_object = new GVRSceneObject(mGVRContext, sphere, m360);
      env_object.getRenderData().setCullTest(false);
      mainScene.addSceneObject(env_object);

      GVRSceneObject headTracker =
          new GVRSceneObject(
              gvrContext,
              gvrContext.createQuad(0.1f, 0.1f),
              gvrContext.loadTexture(
                  new GVRAndroidResource(mGVRContext, "Headtracking_pointer.png")));
      headTracker.getTransform().setPosition(0.0f, 0.0f, -EYE_TO_OBJECT);
      headTracker.getRenderData().setDepthTest(false);
      headTracker.getRenderData().setRenderingOrder(100000);
      mainScene.getMainCameraRig().getOwnerObject().addChildObject(headTracker);
    } catch (IOException e) {
      e.printStackTrace();
      mActivity.finish();
      Log.e(TAG, "Assets were not loaded. Stopping application!");
    }
    // activity was stored in order to stop the application if the mesh is
    // not loaded. Since we don't need anymore, we set it to null to reduce
    // chance of memory leak.
    mActivity = null;
  }