private Matrix4 createLightViewProjectionMatrix(DirectionalLight light) {
//
// -- Get the frustum corners in world space
//
mCamera.getFrustumCorners(mFrustumCorners, true);
//
// -- Get the frustum centroid
//
mFrustumCentroid.setAll(0, 0, 0);
for (int i = 0; i < 8; i++) mFrustumCentroid.add(mFrustumCorners[i]);
mFrustumCentroid.divide(8.0);
//
// --
//
BoundingBox lightBox = new BoundingBox(mFrustumCorners);
double distance = mFrustumCentroid.distanceTo(lightBox.getMin());
Vector3 lightDirection = light.getDirectionVector().clone();
lightDirection.normalize();
Vector3 lightPosition =
Vector3.subtractAndCreate(
mFrustumCentroid, Vector3.multiplyAndCreate(lightDirection, distance));
//
// --
//
mLightViewMatrix.setToLookAt(lightPosition, mFrustumCentroid, Vector3.Y);
for (int i = 0; i < 8; i++) mFrustumCorners[i].multiply(mLightViewMatrix);
BoundingBox b = new BoundingBox(mFrustumCorners);
mLightProjectionMatrix.setToOrthographic(
b.getMin().x, b.getMax().x, b.getMin().y, b.getMax().y, -b.getMax().z, -b.getMin().z);
mLightModelViewProjectionMatrix.setAll(mLightProjectionMatrix);
mLightModelViewProjectionMatrix.multiply(mLightViewMatrix);
return mLightModelViewProjectionMatrix;
}
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);
}
}
}
}
/**
* Constructs a new {@link Matrix4} based on the given matrix.
*
* @param matrix {@link Matrix4} The matrix to clone.
*/
public Matrix4(@NonNull Matrix4 matrix) {
setAll(matrix);
}
/**
* Constructs a {@link Matrix4} based on the rotation represented by the provided {@link
* Quaternion}.
*
* @param quat {@link Quaternion} The {@link Quaternion} to be copied.
*/
public Matrix4(@NonNull Quaternion quat) {
setAll(quat);
}
/**
* Constructs a new {@link Matrix4} based on the provided double array. The array length must be
* greater than or equal to 16 and the array will be copied from the 0 index.
*
* @param matrix double array containing the values for the matrix in column major order. The
* array is not modified or referenced after this constructor completes.
*/
public Matrix4(@NonNull @Size(min = 16) double[] matrix) {
setAll(matrix);
}
/**
* Calculates the model matrix for this {@link ATransformable3D} object.
*
* @param parentMatrix {@link Matrix4} The parent matrix, if any, to apply to this object.
*/
public void calculateModelMatrix(final Matrix4 parentMatrix) {
mMMatrix.setAll(mPosition, mScale, mOrientation);
if (parentMatrix != null) {
mMMatrix.leftMultiply(parentMatrix);
}
}