/** * Fetch the maximum bounds of the scene. * * @return {@link Vector3} containing the maximum values along each axis. */ public Vector3 getSceneMaxBound() { if (mSceneGraph != null) { return mSceneGraph.getSceneMaxBound(); } else { return new Vector3(Float.MAX_VALUE, Float.MAX_VALUE, Float.MAX_VALUE); } }
/** * Recalculates the model matrix for this {@link ATransformable3D} object if necessary. * * @param parentMatrix {@link Matrix4} The parent matrix, if any, to apply to this object. * @return A flag indicating whether the model matrix was recalculated or not. */ public boolean onRecalculateModelMatrix(Matrix4 parentMatrix) { if (mIsModelMatrixDirty) { calculateModelMatrix(parentMatrix); if (mGraphNode != null) mGraphNode.updateObject(this); mIsModelMatrixDirty = false; return true; } return false; }
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); } } } }