@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);
  }
Ejemplo n.º 2
0
  /**
   * Constructor.
   *
   * @param gvrContext The GVR Context.
   * @param language The language of the script file. Please use the constants {@code LANG_*}
   *     defined in {@link GVRScriptManager}, such as {@code LANG_LUA}, {@code LANG_JAVASCRIPT}, and
   *     so on.
   */
  public GVRScriptFile(GVRContext gvrContext, String language) {
    mGvrContext = gvrContext;
    mLanguage = language;

    // Get an engine because some impl. requires a new engine to
    // enforce context
    ScriptEngine engine = mGvrContext.getScriptManager().getEngine(mLanguage);
    mLocalEngine = engine.getFactory().getScriptEngine();

    // Add globals
    mGvrContext.getScriptManager().addGlobalBindings(mLocalEngine);
  }
Ejemplo n.º 3
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);
  }
Ejemplo n.º 4
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);
  }
Ejemplo n.º 5
0
 public CustomShaderManager(GVRContext gvrContext) {
   final GVRMaterialShaderManager shaderManager = gvrContext.getMaterialShaderManager();
   shaderId = shaderManager.addShader(R.raw.vertex, R.raw.fragment);
   GVRMaterialMap customShader = shaderManager.getShaderMap(shaderId);
   customShader.addUniformVec3Key("u_color", COLOR_KEY);
   customShader.addTextureKey("u_texture", TEXTURE_KEY);
 }
Ejemplo n.º 6
0
  private static synchronized GVRPostEffectShaderId getShaderId(GVRContext gvrContext) {
    if (shaderId == null) {
      GVRPostEffectShaderManager shaderManager = gvrContext.getPostEffectShaderManager();
      shaderId = shaderManager.addShader(R.raw.posteffect_quad, R.raw.hud_console);

      shaderMap = shaderManager.getShaderMap(shaderId);
      shaderMap.addTextureKey("u_overlay", MAIN_TEXTURE);
    }
    return shaderId;
  }
Ejemplo n.º 7
0
 private void setTextOnMainThread(final String text) {
   gvrContext
       .getActivity()
       .runOnUiThread(
           new Runnable() {
             @Override
             public void run() {
               textView.setText(text);
             }
           });
 }
Ejemplo n.º 8
0
 public Cube(GVRContext gvrContext, String name, CustomShaderManager shaderManager) {
   super(gvrContext, true);
   Future<GVRTexture> texture =
       gvrContext.loadFutureTexture(new GVRAndroidResource(gvrContext, R.raw.cube_texture));
   GVRMaterial material = getRenderData().getMaterial();
   material.setShaderType(shaderManager.getShaderId());
   setColor(material, 0.7f, 0.7f, 0.7f);
   material.setTexture(CustomShaderManager.TEXTURE_KEY, texture);
   getTransform().setScale(2.0f, 2.0f, 2.0f);
   setName(name);
 }
Ejemplo n.º 9
0
  static {
    GVRContext.addResetOnRestartHandler(
        new Runnable() {

          @Override
          public void run() {
            shaderId = null; // should be enough
            shaderMap = null; // can't hurt
          }
        });
  }
Ejemplo n.º 10
0
  private String enterLanguage(String language) {
    ScriptEngine engine = mGVRContext.getScriptManager().getEngine(language);

    if (engine == null) {
      return "Cannot find the language engine for " + language;
    }

    mScriptHandler = new ScriptHandler(mGVRContext, language, engine);
    mShell.setLineProcessor(mScriptHandler);

    return null;
  }
Ejemplo n.º 11
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);
  }
Ejemplo n.º 12
0
  public PhongShader2(GVRContext gvrContext) {
    final GVRMaterialShaderManager shaderManager = gvrContext.getMaterialShaderManager();
    mShaderId = shaderManager.addShader(VERTEX_SHADER, FRAGMENT_SHADER);
    mCustomShader = shaderManager.getShaderMap(mShaderId);
    mCustomShader.addUniformVec4Key("u_color", COLOR_KEY);
    mCustomShader.addUniformVec3Key("u_light", LIGHT_KEY);
    mCustomShader.addUniformVec3Key("u_eye", EYE_KEY);
    mCustomShader.addUniformFloatKey("u_radius", RADIUS_KEY);
    mCustomShader.addTextureKey("intexture", TEXTURE_KEY);

    mCustomShader.addUniformVec4Key("u_mat1", MAT1_KEY);
    mCustomShader.addUniformVec4Key("u_mat2", MAT2_KEY);
    mCustomShader.addUniformVec4Key("u_mat3", MAT3_KEY);
    mCustomShader.addUniformVec4Key("u_mat4", MAT4_KEY);
  }
Ejemplo n.º 13
0
  public Dashboard(GVRContext gvrContext, int gVRAndroidResourceTexture) {

    super(
        gvrContext,
        HIGHT,
        WIDTH,
        gvrContext.loadTexture(new GVRAndroidResource(gvrContext, gVRAndroidResourceTexture)));
    setName(SceneObjectNames.DASHBOARD);

    Dashboard.currentDashboardHashCode = this.hashCode();

    originalRotationX = getTransform().getRotationX();
    originalRotationY = getTransform().getRotationY();
    originalRotationZ = getTransform().getRotationZ();
    originalRotationW = getTransform().getRotationW();

    attachEyePointeeHolder();
  }
  public TransparentButtonShaderThreeStates(GVRContext gvrContext) {
    final GVRMaterialShaderManager shaderManager = gvrContext.getMaterialShaderManager();
    mShaderId = shaderManager.addShader(VERTEX_SHADER, FRAGMENT_SHADER);
    mCustomShader = shaderManager.getShaderMap(mShaderId);
    mCustomShader.addTextureKey("texture", TEXTURE_KEY);

    mCustomShader.addTextureKey("textureHover", TEXTURE_HOVER_KEY);
    mCustomShader.addTextureKey("textHoverTexture", TEXTURE_TEXT_HOVER_KEY);

    mCustomShader.addTextureKey("textUpperTexture", TEXTURE_TEXT_UPPER_KEY);
    mCustomShader.addTextureKey("textHoverUpperTexture", TEXTURE_TEXT_HOVER_UPPER_KEY);

    mCustomShader.addTextureKey(TEXTURE_TEXT_SPECIAL_KEY, TEXTURE_TEXT_SPECIAL_KEY);
    mCustomShader.addTextureKey(TEXTURE_TEXT_HOVER_SPECIAL_KEY, TEXTURE_TEXT_HOVER_SPECIAL_KEY);

    mCustomShader.addTextureKey("textTexture", TEXTURE_TEXT_KEY);
    mCustomShader.addUniformFloatKey("opacity", OPACITY);
    mCustomShader.addUniformFloatKey("textureSwitch", TEXTURE_SWITCH);
  }
Ejemplo n.º 15
0
    private void processMouseEvent(float x, float y, float z, boolean active) {
      GVRScene scene = context.getMainScene();
      if (scene != null) {
        float depth = this.z;
        if (((depth + z) <= getNearDepth()) && ((depth + z) >= getFarDepth())) {
          float frustumWidth, frustumHeight;
          depth = depth + z;

          // calculate the frustum using the aspect ratio and FOV
          // http://docs.unity3d.com/Manual/FrustumSizeAtDistance.html
          float aspectRatio = scene.getMainCameraRig().getCenterCamera().getAspectRatio();
          float fovY = scene.getMainCameraRig().getCenterCamera().getFovY();
          float frustumHeightMultiplier = (float) Math.tan(Math.toRadians(fovY / 2)) * 2.0f;
          frustumHeight = frustumHeightMultiplier * depth;
          frustumWidth = frustumHeight * aspectRatio;

          this.x = frustumWidth * -x;
          this.y = frustumHeight * -y;
          this.z = depth;
        }
        setActive(active);
        super.setPosition(this.x, this.y, this.z);
      }
    }
Ejemplo n.º 16
0
 void close() {
   gvrContext.getInputManager().removeCursorControllerListener(this);
 }
Ejemplo n.º 17
0
 private static double calculateScaleRateBasedOnCurrentNativeFontScale(GVRContext gvrContext) {
   float fontScale = gvrContext.getContext().getResources().getConfiguration().fontScale;
   return (fontScale / LARGEST_FONT_SCALE);
 }
Ejemplo n.º 18
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;
  }
Ejemplo n.º 19
0
  @Override
  public void onStep() {
    FPSCounter.tick();

    boolean isButtonDown = mIsButtonDown;
    boolean isSingleTapped = mIsSingleTapped;
    mIsButtonDown = false;
    mIsSingleTapped = false;

    if (isButtonDown) mGVRContext.getMainScene().getMainCameraRig().resetYaw();

    // ---------------------------------------thumbnail motion
    boolean MoveActive = false;
    if (Math.abs(
            ThumbnailTargetPosition[ThumbnailTargetIndex[0]][0] - ThumbnailCurrentPosition[0][0])
        < 0.2f) MoveActive = true;

    if (SelectionActive && MoveActive) {
      if (ThumbnailCurrentPosition[ThumbnailSelected][0] < -0.5f) {
        for (int i = 0; i < THUMBNAIL_NUM; i++) {
          ThumbnailTargetIndex[i]++;
          if (ThumbnailTargetIndex[i] >= THUMBNAIL_NUM)
            ThumbnailTargetIndex[i] = ThumbnailTargetIndex[i] - THUMBNAIL_NUM;
          if (ThumbnailTargetIndex[i] < 0)
            ThumbnailTargetIndex[i] = ThumbnailTargetIndex[i] + THUMBNAIL_NUM;
        }
      } else if (ThumbnailCurrentPosition[ThumbnailSelected][0] > 0.5f) {
        for (int i = 0; i < THUMBNAIL_NUM; i++) {
          ThumbnailTargetIndex[i]--;
          if (ThumbnailTargetIndex[i] >= THUMBNAIL_NUM)
            ThumbnailTargetIndex[i] = ThumbnailTargetIndex[i] - THUMBNAIL_NUM;
          if (ThumbnailTargetIndex[i] < 0)
            ThumbnailTargetIndex[i] = ThumbnailTargetIndex[i] + THUMBNAIL_NUM;
        }
      }
    }

    for (int i = 0; i < THUMBNAIL_NUM; i++) {
      float speed = 0.08f;
      for (int j = 0; j < 3; j++)
        ThumbnailCurrentPosition[i][j] +=
            speed
                * (ThumbnailTargetPosition[ThumbnailTargetIndex[i]][j]
                    - ThumbnailCurrentPosition[i][j]);
      ThumbnailObject[i]
          .getTransform()
          .setPosition(
              ThumbnailCurrentPosition[i][0],
              ThumbnailCurrentPosition[i][1],
              ThumbnailCurrentPosition[i][2]);
    }

    // if(
    // Math.abs(ThumbnailTargetPosition[ThumbnailTargetIndex[0]][0]-ThumbnailCurrentPosition[0][0])
    // > 0.02f )
    // {
    // if( THUMBNAIL_ROT > 180.0f )
    // THUMBNAIL_ROT += 0.05f*( 360.0f - THUMBNAIL_ROT );
    // else
    // THUMBNAIL_ROT += 0.05f*( 0.0f - THUMBNAIL_ROT );
    // }
    // else
    // {
    // THUMBNAIL_ROT += -1.0f;
    // if( THUMBNAIL_ROT > 360.0f ) THUMBNAIL_ROT = THUMBNAIL_ROT - 360.0f;
    // }
    THUMBNAIL_ROT = -1.0f;
    for (int i = 0; i < THUMBNAIL_NUM; i++)
      ThumbnailRotation[i].getTransform().rotateByAxis(THUMBNAIL_ROT, 0.0f, 1.0f, 0.0f);

    // ---------------------------------------object motion

    OBJECT_ROT = -1.0f;
    for (int i = 0; i < THUMBNAIL_NUM; i++)
      Objects[i].getTransform().rotateByAxis(OBJECT_ROT, 0.0f, 1.0f, 0.0f);

    float[] light = new float[4];
    light[0] = 6.0f;
    light[1] = 10.0f;
    light[2] = 10.0f;
    light[3] = 1.0f;

    float[] eye = new float[4];
    eye[0] = 0.0f;
    eye[1] = 0.0f;
    eye[2] = 3.0f * EYE_TO_OBJECT;
    eye[3] = 1.0f;

    float[] matT = ThumbnailRotation[0].getTransform().getModelMatrix();
    float[] matO = Objects[ThumbnailSelected].getTransform().getModelMatrix();

    // ---------------------------- watch, jar

    float x = matO[0] * light[0] + matO[1] * light[1] + matO[2] * light[2] + matO[3] * light[3];
    float y = matO[4] * light[0] + matO[5] * light[1] + matO[6] * light[2] + matO[7] * light[3];
    float z = matO[8] * light[0] + matO[9] * light[1] + matO[10] * light[2] + matO[11] * light[3];

    float mag = (float) Math.sqrt(x * x + y * y + z * z);

    mMetalMaterial.setVec3(MetalOnlyShader.LIGHT_KEY, x / mag, y / mag, z / mag);
    mDiffuseMaterial.setVec3(DiffuseShader.LIGHT_KEY, x / mag, y / mag, z / mag);
    mGlassMaterial.setVec3(GlassShader.LIGHT_KEY, x / mag, y / mag, z / mag);
    mPhongMaterial.setVec3(PhongShader.LIGHT_KEY, x / mag, y / mag, z / mag);

    x = matO[0] * eye[0] + matO[1] * eye[1] + matO[2] * eye[2] + matO[3] * eye[3];
    y = matO[4] * eye[0] + matO[5] * eye[1] + matO[6] * eye[2] + matO[7] * eye[3];
    z = matO[8] * eye[0] + matO[9] * eye[1] + matO[10] * eye[2] + matO[11] * eye[3];

    mag = (float) Math.sqrt(x * x + y * y + z * z);

    mMetalMaterial.setVec3(MetalOnlyShader.EYE_KEY, x / mag, y / mag, z / mag);
    mDiffuseMaterial.setVec3(DiffuseShader.EYE_KEY, x / mag, y / mag, z / mag);
    mGlassMaterial.setVec3(GlassShader.EYE_KEY, x / mag, y / mag, z / mag);
    mPhongMaterial.setVec3(PhongShader.EYE_KEY, x / mag, y / mag, z / mag);

    // ---------------------------- robot

    mRobotHeadMaterial.setVec4(PhongShader3.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mRobotHeadMaterial.setVec4(PhongShader3.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mRobotHeadMaterial.setVec4(PhongShader3.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mRobotHeadMaterial.setVec4(PhongShader3.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mRobotHeadMaterial.setVec3(PhongShader3.LIGHT_KEY, light[0], light[1], light[2]);
    mRobotHeadMaterial.setVec3(PhongShader3.EYE_KEY, eye[0], eye[1], eye[2]);

    mRobotMetalMaterial.setVec4(MetalShader2.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mRobotMetalMaterial.setVec4(MetalShader2.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mRobotMetalMaterial.setVec4(MetalShader2.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mRobotMetalMaterial.setVec4(MetalShader2.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mRobotMetalMaterial.setVec3(MetalShader2.LIGHT_KEY, light[0], light[1], light[2]);
    mRobotMetalMaterial.setVec3(MetalShader2.EYE_KEY, eye[0], eye[1], eye[2]);

    mRobotBodyMaterial.setVec4(PhongShader2.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mRobotBodyMaterial.setVec4(PhongShader2.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mRobotBodyMaterial.setVec4(PhongShader2.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mRobotBodyMaterial.setVec4(PhongShader2.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mRobotBodyMaterial.setVec3(PhongShader2.LIGHT_KEY, light[0], light[1], light[2]);
    mRobotBodyMaterial.setVec3(PhongShader2.EYE_KEY, eye[0], eye[1], eye[2]);

    mRobotRubberMaterial.setVec4(DiffuseShader2.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mRobotRubberMaterial.setVec4(DiffuseShader2.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mRobotRubberMaterial.setVec4(DiffuseShader2.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mRobotRubberMaterial.setVec4(DiffuseShader2.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mRobotRubberMaterial.setVec3(DiffuseShader2.LIGHT_KEY, light[0], light[1], light[2]);
    mRobotRubberMaterial.setVec3(DiffuseShader2.EYE_KEY, eye[0], eye[1], eye[2]);

    // ---------------------------- leaf

    mLeafBodyMaterial.setVec4(MetalShader2.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mLeafBodyMaterial.setVec4(MetalShader2.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mLeafBodyMaterial.setVec4(MetalShader2.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mLeafBodyMaterial.setVec4(MetalShader2.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mLeafBodyMaterial.setVec3(MetalShader2.LIGHT_KEY, light[0], light[1], light[2]);
    mLeafBodyMaterial.setVec3(MetalShader2.EYE_KEY, eye[0], eye[1], eye[2]);

    mLeafBoxMaterial.setVec4(PhongShader3.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mLeafBoxMaterial.setVec4(PhongShader3.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mLeafBoxMaterial.setVec4(PhongShader3.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mLeafBoxMaterial.setVec4(PhongShader3.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mLeafBoxMaterial.setVec3(PhongShader3.LIGHT_KEY, light[0], light[1], light[2]);
    mLeafBoxMaterial.setVec3(PhongShader3.EYE_KEY, eye[0], eye[1], eye[2]);

    // ---------------------------- car
    eye[0] = 4.0f;
    eye[1] = 0.0f;
    eye[2] = 3.0f * EYE_TO_OBJECT;
    eye[3] = 1.0f;

    mCarBodyMaterial.setVec4(PhongShader3.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mCarBodyMaterial.setVec4(PhongShader3.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mCarBodyMaterial.setVec4(PhongShader3.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mCarBodyMaterial.setVec4(PhongShader3.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mCarBodyMaterial.setVec3(PhongShader3.LIGHT_KEY, light[0], light[1], light[2]);
    mCarBodyMaterial.setVec3(PhongShader3.EYE_KEY, eye[0], eye[1], eye[2]);

    mCarTireMaterial.setVec4(DiffuseShader2.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mCarTireMaterial.setVec4(DiffuseShader2.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mCarTireMaterial.setVec4(DiffuseShader2.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mCarTireMaterial.setVec4(DiffuseShader2.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mCarTireMaterial.setVec3(DiffuseShader2.LIGHT_KEY, light[0], light[1], light[2]);
    mCarTireMaterial.setVec3(DiffuseShader2.EYE_KEY, eye[0], eye[1], eye[2]);

    mCarGlassMaterial.setVec4(GlassShader2.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mCarGlassMaterial.setVec4(GlassShader2.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mCarGlassMaterial.setVec4(GlassShader2.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mCarGlassMaterial.setVec4(GlassShader2.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mCarGlassMaterial.setVec3(GlassShader2.LIGHT_KEY, light[0], light[1], light[2]);
    mCarGlassMaterial.setVec3(GlassShader2.EYE_KEY, eye[0], eye[1], eye[2]);

    mCarWheelMaterial.setVec4(MetalShader2.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mCarWheelMaterial.setVec4(MetalShader2.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mCarWheelMaterial.setVec4(MetalShader2.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mCarWheelMaterial.setVec4(MetalShader2.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mCarWheelMaterial.setVec3(MetalShader2.LIGHT_KEY, light[0], light[1], light[2]);
    mCarWheelMaterial.setVec3(MetalShader2.EYE_KEY, eye[0], eye[1], eye[2]);

    mCarBackMaterial.setVec4(DiffuseShader2.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mCarBackMaterial.setVec4(DiffuseShader2.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mCarBackMaterial.setVec4(DiffuseShader2.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mCarBackMaterial.setVec4(DiffuseShader2.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mCarBackMaterial.setVec3(DiffuseShader2.LIGHT_KEY, light[0], light[1], light[2]);
    mCarBackMaterial.setVec3(DiffuseShader2.EYE_KEY, eye[0], eye[1], eye[2]);

    mCarGrillMaterial.setVec4(DiffuseShader2.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mCarGrillMaterial.setVec4(DiffuseShader2.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mCarGrillMaterial.setVec4(DiffuseShader2.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mCarGrillMaterial.setVec4(DiffuseShader2.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mCarGrillMaterial.setVec3(DiffuseShader2.LIGHT_KEY, light[0], light[1], light[2]);
    mCarGrillMaterial.setVec3(DiffuseShader2.EYE_KEY, eye[0], eye[1], eye[2]);

    mCarLightMaterial.setVec4(GlassShader2.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mCarLightMaterial.setVec4(GlassShader2.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mCarLightMaterial.setVec4(GlassShader2.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mCarLightMaterial.setVec4(GlassShader2.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mCarLightMaterial.setVec3(GlassShader2.LIGHT_KEY, light[0], light[1], light[2]);
    mCarLightMaterial.setVec3(GlassShader2.EYE_KEY, eye[0], eye[1], eye[2]);

    mCarInsideMaterial.setVec4(PhongShader2.MAT1_KEY, matO[0], matO[4], matO[8], matO[12]);
    mCarInsideMaterial.setVec4(PhongShader2.MAT2_KEY, matO[1], matO[5], matO[9], matO[13]);
    mCarInsideMaterial.setVec4(PhongShader2.MAT3_KEY, matO[2], matO[6], matO[10], matO[14]);
    mCarInsideMaterial.setVec4(PhongShader2.MAT4_KEY, matO[3], matO[7], matO[11], matO[15]);
    mCarInsideMaterial.setVec3(PhongShader2.LIGHT_KEY, light[0], light[1], light[2]);
    mCarInsideMaterial.setVec3(PhongShader2.EYE_KEY, eye[0], eye[1], eye[2]);

    // ---------------------------- thumbnail glasses

    eye[0] = 0.0f;
    eye[1] = 0.0f;
    eye[2] = EYE_TO_OBJECT;
    eye[3] = 1.0f;

    mReflectionMaterial.setVec4(ReflectionShader.MAT1_KEY, matT[0], matT[4], matT[8], matT[12]);
    mReflectionMaterial.setVec4(ReflectionShader.MAT2_KEY, matT[1], matT[5], matT[9], matT[13]);
    mReflectionMaterial.setVec4(ReflectionShader.MAT3_KEY, matT[2], matT[6], matT[10], matT[14]);
    mReflectionMaterial.setVec4(ReflectionShader.MAT4_KEY, matT[3], matT[7], matT[11], matT[15]);
    mReflectionMaterial.setVec3(ReflectionShader.LIGHT_KEY, light[0], light[1], light[2]);
    mReflectionMaterial.setVec3(ReflectionShader.EYE_KEY, eye[0], eye[1], eye[2]);

    GVREyePointeeHolder pickedHolders[] = GVRPicker.pickScene(mGVRContext.getMainScene());
    if (SelectionMode && pickedHolders.length > 0) {
      GVRSceneObject pickedObject = pickedHolders[0].getOwnerObject();
      for (int i = 0; i < THUMBNAIL_NUM; ++i)
        if (ThumbnailObject[i].equals(pickedObject)) {
          ThumbnailSelected = i;
          break;
        }
      SelectionActive = true;
    } else SelectionActive = false;

    if (isSingleTapped) {
      SelectionMode = !SelectionMode;
      if (SelectionMode) {
        for (int i = 0; i < THUMBNAIL_NUM; ++i) {
          ThumbnailGlasses[i].setRenderMask(GVRRenderMaskBit.Left | GVRRenderMaskBit.Right);
          Thumbnails[i]
              .getRenderData()
              .setRenderMask(GVRRenderMaskBit.Left | GVRRenderMaskBit.Right);
        }
        for (int I = 0; I < THUMBNAIL_NUM; I++)
          for (int i = 0; i < Objects[I].getChildrenCount(); i++)
            Objects[I].getChildByIndex(i).getRenderData().setRenderMask(0);
      } else {
        for (int i = 0; i < THUMBNAIL_NUM; ++i) {
          ThumbnailGlasses[i].setRenderMask(0);
          Thumbnails[i].getRenderData().setRenderMask(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);
        for (int i = 0; i < Objects[ThumbnailSelected].getChildrenCount(); i++)
          Objects[ThumbnailSelected]
              .getChildByIndex(i)
              .getRenderData()
              .setRenderMask(GVRRenderMaskBit.Left | GVRRenderMaskBit.Right);
      }
    }
  }
Ejemplo n.º 20
0
 /**
  * Create a console, specifying the initial eye mode.
  *
  * @param gvrContext The GVR context.
  * @param startMode The initial eye mode; you can change this <i>via</i> {@link
  *     #setEyeMode(EyeMode)}
  */
 public GVRConsole(GVRContext gvrContext, EyeMode startMode) {
   this(gvrContext, startMode, gvrContext.getMainScene());
 }