Renderer.java

Go to the documentation of this file.

/*
 * Copyright 2014 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.introlab.rtabmap;

import java.util.Vector;
import java.util.concurrent.locks.ReentrantLock;

import android.app.Activity;
import android.app.ProgressDialog;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.opengl.Matrix;
import android.util.Log;
import android.widget.Toast;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

// Renderer renders graphic content. This includes the point cloud,
// ground grid, camera frustum, camera axis, and trajectory based on the Tango
// device's pose.
public class Renderer implements GLSurfaceView.Renderer {

        private final float[] mtrxProjection = new float[16];
        private final float[] mtrxView = new float[16];
        private final float[] mtrxProjectionAndView = new float[16];

        private TextManager mTextManager = null;
        private float mSurfaceHeight = 0.0f;
        private float mTextColor = 1.0f;
        private int mOffset = 0;
        
        private Vector<TextObject> mTexts;

        private static RTABMapActivity mActivity;
        public Renderer(RTABMapActivity c) {
                mActivity = c;
        }

        private ProgressDialog mProgressDialog = null;
        private Toast mToast = null;
        
        private boolean mTextChanged = false;
        private ReentrantLock mTextLock = new ReentrantLock();

        public void setProgressDialog(ProgressDialog progressDialog)
        {
                mProgressDialog = progressDialog;
        }

        public void setToast(Toast toast)
        {
                mToast = toast;
        }
        
        public void setOffset(int offset)
        {
                mOffset = offset;
        }

        // Render loop of the Gl context.
        public void onDrawFrame(GL10 useGLES20instead) {

                try
                {
                        final int value = RTABMapLib.render();

                        if(mTextManager!=null)
                        {
                                if(mTextChanged)
                                {
                                        mTextChanged = false;
                                        Vector<TextObject> txtcollection = new Vector<TextObject>();
                                        
                                        mTextLock.lock();
                                    try {
                                        if(mTexts.size() > 0)
                                        {
                                                txtcollection.addAll(mTexts);
                                        }
                                    } finally {
                                        mTextLock.unlock();
                                    }
                                    
                                        // Prepare the text for rendering
                                        mTextManager.PrepareDraw(txtcollection);
                                }
                                
                                float[] mvp = new float[16];
                                Matrix.translateM(mvp, 0, mtrxProjectionAndView, 0, 0, mOffset, 0);
                                mTextManager.Draw(mvp);
                        }

                        if(value != 0 && mProgressDialog != null && mProgressDialog.isShowing())
                        {
                                mActivity.runOnUiThread(new Runnable() {
                                        public void run() {
                                                if(!RTABMapActivity.DISABLE_LOG) Log.i("RTABMapActivity", "Renderer: dismiss dialog, value received=" + String.valueOf(value));
                                                mProgressDialog.dismiss();
                                                mActivity.resetNoTouchTimer();
                                        }
                                });
                        }
                        if(value==-1)
                        {
                                mActivity.runOnUiThread(new Runnable() {
                                        public void run() {
                                                if(mToast!=null)
                                                {
                                                        mToast.makeText(mActivity, String.format("Out of Memory!"), Toast.LENGTH_SHORT).show();
                                                }
                                        }
                                });
                        }
                        else if(value==-2)
                        {
                                mActivity.runOnUiThread(new Runnable() {
                                        public void run() {
                                                if(mToast!=null)
                                                {
                                                        mToast.makeText(mActivity, String.format("Rendering Error!"), Toast.LENGTH_SHORT).show();
                                                }
                                        }
                                });
                        }
                }
                catch(final Exception e)
                {
                        mActivity.runOnUiThread(new Runnable() {
                                public void run() {
                                        if(mToast!=null)
                                        {
                                                mToast.makeText(mActivity, String.format("Rendering error! %s", e.getMessage()), Toast.LENGTH_SHORT).show();
                                        }
                                }

                        });
                }
        }

        // Called when the surface size changes.
        public void onSurfaceChanged(GL10 useGLES20instead, int width, int height) {
                
                RTABMapLib.setupGraphic(width, height);
                
                mSurfaceHeight = (float)height;

                // Clear our matrices
                for(int i=0;i<16;i++)
                {
                        mtrxProjection[i] = 0.0f;
                        mtrxView[i] = 0.0f;
                        mtrxProjectionAndView[i] = 0.0f;
                }

                // Setup our screen width and height for normal sprite translation.
                Matrix.orthoM(mtrxProjection, 0, 0f, width, 0.0f, height, 0, 50);

                // Set the camera position (View matrix)
                Matrix.setLookAtM(mtrxView, 0, 0f, 0f, 1f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

                // Calculate the projection and view transformation
                Matrix.multiplyMM(mtrxProjectionAndView, 0, mtrxProjection, 0, mtrxView, 0);
        }

        // Called when the surface is created or recreated.
        public void onSurfaceCreated(GL10 useGLES20instead, EGLConfig config) {

                RTABMapLib.initGlContent();
                
                // Create our text manager
                mTextManager = new TextManager(mActivity);
                mTextManager.setColor(mTextColor);
        }
        
        public void updateTexts(String[] texts)
        {
                if(mTextManager != null && mSurfaceHeight > 0.0f)
                {
                        Vector<TextObject> textObjects = new Vector<TextObject>();
                        float offset = mSurfaceHeight-mTextManager.getMaxTextHeight();
                        if(texts != null)
                        {
                                for(int i=0;i<texts.length; ++i)
                                {
                                        if(texts[i]!=null && texts[i].length()>0)
                                        {
                                                TextObject txt = new TextObject(texts[i], 0, offset);
                                                textObjects.add(txt);
                                        }
                                        offset-=mTextManager.getMaxTextHeight();
                                }
                        }
        
                        mTextLock.lock();
                        try {
                                mTexts = textObjects;
                        } finally {
                                mTextLock.unlock();
                        }
        
                        mTextChanged = true;
                }
        }
        
        public void setTextColor(float color) 
        {
                mTextColor = color;
                if(mTextManager != null)
                {
                        mTextManager.setColor(mTextColor);
                }
        }
}