예제 #1
0
  /**
   * Updates the sky box textures with a bitmap array of length 6.
   *
   * @param bitmaps {@link Bitmap} array containing the cube map textures. The sequence of the
   *     bitmaps in array should be front, right, back, left, up, down, the same as in
   *     setSkybox(Bitmap[] bitmaps)
   * @throws Exception
   */
  public void updateSkybox(Bitmap[] bitmaps) throws Exception {
    if (mSkyboxTexture.getClass() != CubeMapTexture.class)
      throw new Exception("The skybox texture cannot be updated. It is not a cube map texture.");

    CubeMapTexture cubemap = (CubeMapTexture) mSkyboxTexture;
    cubemap.setBitmaps(bitmaps);
    mRenderer.getTextureManager().replaceTexture(cubemap);
  }
예제 #2
0
  /**
   * Updates the sky box textures with a single texture.
   *
   * @param resourceId int the resource id of the new texture.
   * @throws Exception
   */
  public void updateSkybox(int resourceId) throws Exception {
    if (mSkyboxTexture.getClass() != Texture.class)
      throw new Exception("The skybox texture cannot be updated.");

    Texture texture = (Texture) mSkyboxTexture;
    texture.setResourceId(resourceId);
    mRenderer.getTextureManager().replaceTexture(texture);
  }
예제 #3
0
 @Override
 public void render(
     Scene scene,
     Renderer renderer,
     ScreenQuad screenQuad,
     RenderTarget writeBuffer,
     RenderTarget readBuffer,
     long ellapsedTime,
     double deltaTime) {
   if (mShadowPassType == ShadowPassType.APPLY_SHADOW_MAP) {
     mShadowMapMaterial.setShadowMapTexture(mShadowRenderTarget.getTexture());
     super.render(scene, renderer, screenQuad, writeBuffer, readBuffer, ellapsedTime, deltaTime);
   } else {
     renderer.setOverrideViewportDimensions(mShadowMapSize, mShadowMapSize);
     super.render(
         scene, renderer, screenQuad, mShadowRenderTarget, readBuffer, ellapsedTime, deltaTime);
     renderer.clearOverrideViewportDimensions();
   }
 }
예제 #4
0
  /**
   * Updates the sky box textures with 6 new resource ids.
   *
   * @param front int Resource id for the front face.
   * @param right int Resource id for the right face.
   * @param back int Resource id for the back face.
   * @param left int Resource id for the left face.
   * @param up int Resource id for the up face.
   * @param down int Resource id for the down face.
   * @throws Exception
   */
  public void updateSkybox(int front, int right, int back, int left, int up, int down)
      throws Exception {
    if (mSkyboxTexture.getClass() != CubeMapTexture.class)
      throw new Exception("The skybox texture cannot be updated. It is not a cube map texture.");

    int[] resourceIds = new int[] {front, right, back, left, up, down};

    CubeMapTexture cubemap = (CubeMapTexture) mSkyboxTexture;
    cubemap.setResourceIds(resourceIds);
    mRenderer.getTextureManager().replaceTexture(cubemap);
  }
예제 #5
0
  public void render(
      long ellapsedTime, double deltaTime, RenderTarget renderTarget, Material sceneMaterial) {
    // Scene color-picking requests are relative to the prior frame's render
    // state, so handle any pending request before applying this frame's updates...
    if (mPickerInfo != null) {
      doColorPicking(mPickerInfo);
      // One-shot, once per frame at most
      mPickerInfo = null;
    }

    performFrameTasks(); // Handle the task queue

    synchronized (mFrameTaskQueue) {
      if (mLightsDirty) {
        updateMaterialsWithLights();
        mLightsDirty = false;
      }
    }

    synchronized (mNextSkyboxLock) {
      // Check if we need to switch the skybox, and if so, do it.
      if (mNextSkybox != null) {
        mSkybox = mNextSkybox;
        mNextSkybox = null;
      }
    }
    synchronized (mNextCameraLock) {
      // Check if we need to switch the camera, and if so, do it.
      if (mNextCamera != null) {
        mCamera = mNextCamera;
        mCamera.setProjectionMatrix(mRenderer.getViewportWidth(), mRenderer.getViewportHeight());
        mNextCamera = null;
      }
    }

    int clearMask = mAlwaysClearColorBuffer ? GLES20.GL_COLOR_BUFFER_BIT : 0;

    if (renderTarget != null) {
      renderTarget.bind();
      GLES20.glClearColor(mRed, mGreen, mBlue, mAlpha);
    } else {
      //			GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
      GLES20.glClearColor(mRed, mGreen, mBlue, mAlpha);
    }

    if (mEnableDepthBuffer) {
      clearMask |= GLES20.GL_DEPTH_BUFFER_BIT;
      GLES20.glEnable(GLES20.GL_DEPTH_TEST);
      GLES20.glDepthFunc(GLES20.GL_LESS);
      GLES20.glDepthMask(true);
      GLES20.glClearDepthf(1.0f);
    }
    if (mAntiAliasingConfig.equals(ISurface.ANTI_ALIASING_CONFIG.COVERAGE)) {
      clearMask |= GL_COVERAGE_BUFFER_BIT_NV;
    }

    GLES20.glClear(clearMask);

    // Execute onPreFrame callbacks
    // We explicitly break out the steps here to help the compiler optimize
    final int preCount = mPreCallbacks.size();
    if (preCount > 0) {
      synchronized (mPreCallbacks) {
        for (int i = 0; i < preCount; ++i) {
          mPreCallbacks.get(i).onPreFrame(ellapsedTime, deltaTime);
        }
      }
    }

    // Update all registered animations
    synchronized (mAnimations) {
      for (int i = 0, j = mAnimations.size(); i < j; ++i) {
        Animation anim = mAnimations.get(i);
        if (anim.isPlaying()) anim.update(deltaTime);
      }
    }

    // We are beginning the render process so we need to update the camera matrix before fetching
    // its values
    mCamera.onRecalculateModelMatrix(null);

    // Get the view and projection matrices in advance
    mVMatrix = mCamera.getViewMatrix();
    mPMatrix = mCamera.getProjectionMatrix();
    // Pre-multiply View and Projection matrices once for speed
    mVPMatrix.setAll(mPMatrix).multiply(mVMatrix);
    mInvVPMatrix.setAll(mVPMatrix).inverse();
    mCamera.updateFrustum(mInvVPMatrix); // Update frustum plane

    // Update the model matrices of all the lights
    synchronized (mLights) {
      final int numLights = mLights.size();
      for (int i = 0; i < numLights; ++i) {
        mLights.get(i).onRecalculateModelMatrix(null);
      }
    }

    // Execute onPreDraw callbacks
    // We explicitly break out the steps here to help the compiler optimize
    final int preDrawCount = mPreDrawCallbacks.size();
    if (preDrawCount > 0) {
      synchronized (mPreDrawCallbacks) {
        for (int i = 0; i < preDrawCount; ++i) {
          mPreDrawCallbacks.get(i).onPreDraw(ellapsedTime, deltaTime);
        }
      }
    }

    if (mSkybox != null) {
      GLES20.glDisable(GLES20.GL_DEPTH_TEST);
      GLES20.glDepthMask(false);

      mSkybox.setPosition(mCamera.getX(), mCamera.getY(), mCamera.getZ());
      // Model matrix updates are deferred to the render method due to parent matrix needs
      // Render the skybox
      mSkybox.render(mCamera, mVPMatrix, mPMatrix, mVMatrix, null);

      if (mEnableDepthBuffer) {
        GLES20.glEnable(GLES20.GL_DEPTH_TEST);
        GLES20.glDepthMask(true);
      }
    }

    if (sceneMaterial != null) {
      sceneMaterial.useProgram();
      sceneMaterial.bindTextures();
    }

    synchronized (mChildren) {
      for (int i = 0, j = mChildren.size(); i < j; ++i) {
        // Model matrix updates are deferred to the render method due to parent matrix needs
        mChildren.get(i).render(mCamera, mVPMatrix, mPMatrix, mVMatrix, sceneMaterial);
      }
    }

    if (mDisplaySceneGraph) {
      mSceneGraph.displayGraph(mCamera, mVPMatrix, mPMatrix, mVMatrix);
    }

    if (sceneMaterial != null) {
      sceneMaterial.unbindTextures();
    }

    synchronized (mPlugins) {
      for (int i = 0, j = mPlugins.size(); i < j; i++) mPlugins.get(i).render();
    }

    if (renderTarget != null) {
      renderTarget.unbind();
    }

    // Execute onPostFrame callbacks
    // We explicitly break out the steps here to help the compiler optimize
    final int postCount = mPostCallbacks.size();
    if (postCount > 0) {
      synchronized (mPostCallbacks) {
        for (int i = 0; i < postCount; ++i) {
          mPostCallbacks.get(i).onPostFrame(ellapsedTime, deltaTime);
        }
      }
    }
  }