gl_code.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * 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.
 */

// OpenGL ES 2.0 code

#include <jni.h>
#include <android/log.h>
#include "camera.h"


#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>

#include <Eigen/Geometry>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "pcl/filters/filter.h"
#include "pcl/filters/voxel_grid.h"
#include "pcl/io/pcd_io.h"
#include "pcl/point_types.h"

using namespace Eigen;

#define  LOG_TAG    "libgl2jni"
#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)

static void printGLString(const char *name, GLenum s) {
    const char *v = (const char *) glGetString(s);
    LOGI("GL %s = %s\n", name, v);
}

static void checkGlError(const char* op) {
    for (GLint error = glGetError(); error; error
            = glGetError()) {
        LOGI("after %s() glError (0x%x)\n", op, error);
    }
}
//vec3(a_color[0]/255.0,a_color[1]/255.0,a_color[2]/255.0);       
static const char gVertexShader[] =
    "uniform mat4 u_mvpMatrix;                   \n"
    "attribute vec4 a_position; \n"
    "attribute vec3 a_color;    \n"
    "varying vec4 v_color;      \n"
    "void main() { \n"
    "  gl_Position = u_mvpMatrix * a_position;\n"
    "  gl_PointSize = 2.0;      \n"
    "  v_color = vec4(a_color[2]/255.0,a_color[1]/255.0,a_color[0]/255.0,1.0);\n"
    "}                          \n";

static const char gFragmentShader[] = 
    "precision mediump float;\n"
    "varying vec4 v_color;         \n"
    "void main() {\n"
    //"  gl_FragColor = vec4(1.0,0.5,1.0,1.0);\n"
    "  gl_FragColor = v_color;\n"
    "}\n";

GLuint loadShader(GLenum shaderType, const char* pSource) {
    GLuint shader = glCreateShader(shaderType);
    if (shader) {
        glShaderSource(shader, 1, &pSource, NULL);
        glCompileShader(shader);
        GLint compiled = 0;
        glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
        if (!compiled) {
            GLint infoLen = 0;
            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
            if (infoLen) {
                char* buf = (char*) malloc(infoLen);
                if (buf) {
                    glGetShaderInfoLog(shader, infoLen, NULL, buf);
                    LOGE("Could not compile shader %d:\n%s\n",
                            shaderType, buf);
                    free(buf);
                }
                glDeleteShader(shader);
                shader = 0;
            }
        }
    }
    return shader;
}

GLuint createProgram(const char* pVertexSource, const char* pFragmentSource) {
    GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
    if (!vertexShader) {
        return 0;
    }

    GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
    if (!pixelShader) {
        return 0;
    }

    GLuint program = glCreateProgram();
    if (program) {
        glAttachShader(program, vertexShader);
        checkGlError("glAttachShader");
        glAttachShader(program, pixelShader);
        checkGlError("glAttachShader");
        glLinkProgram(program);
        GLint linkStatus = GL_FALSE;
        glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
        if (linkStatus != GL_TRUE) {
            GLint bufLength = 0;
            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
            if (bufLength) {
                char* buf = (char*) malloc(bufLength);
                if (buf) {
                    glGetProgramInfoLog(program, bufLength, NULL, buf);
                    LOGE("Could not link program:\n%s\n", buf);
                    free(buf);
                }
            }
            glDeleteProgram(program);
            program = 0;
        }
    }
    return program;
}

Camera camera;
GLuint gProgram;
GLuint gvPositionHandle;
GLuint gvColorHandle;
  // Uniform locations
GLint  gvTransformM;

struct CloudRawRGB
{
  typedef pcl::PointXYZRGB Point;
  typedef pcl::PointCloud<Point> Cloud;

  typedef unsigned char UByte;
  static const size_t STEP_V = sizeof(Point) / sizeof(UByte); // the step from one point start to the next
  static const size_t PER_V = 3; //X,Y,Z
  static const size_t STEP_C = sizeof(Point) / sizeof(UByte); // the step from one color start to the next
  static const size_t PER_C = 3; //R,G,B
  const float* verts; 
  const UByte* colors; 
  size_t n; 

  CloudRawRGB():
  verts(0), colors(0), n(0), glbuffer(0),loaded(false)
  {}
  CloudRawRGB(const Cloud& cloud) :
    verts(GetVerts(cloud)), colors(GetColors(cloud)), n(cloud.size()), glbuffer(0),loaded(false)
  {
   
   
  }
  void bind() const {
    glBindBuffer(GL_ARRAY_BUFFER, glbuffer);
  }
  
  void loadIntoGLBuffer()
  {
    if(glbuffer > 0){
        glDeleteBuffers(1,&glbuffer);
    }else
        glGenBuffers(1,&glbuffer);
    bind();
    glBufferData(       GL_ARRAY_BUFFER,
        n * sizeof(Point),
        verts,
        GL_STATIC_DRAW);
    
  }

  static const float* GetVerts(const Cloud& cloud)
  {
    return cloud.points[0].data;
  }

  static const UByte* GetColors(const Cloud& cloud)
  {
    //cast to void* to get rid of strict aliasing warning
    const void * vp = reinterpret_cast<const void*> (&(cloud.points[0].rgb));
    //cast to unsigned char float -> int -> UByte[4] , where UByte[0] is R [1] is B [2] is G (have to test this)
    const UByte* colors = reinterpret_cast<const UByte*> (vp);
    return colors;
  }
  GLuint glbuffer;
  bool loaded;
};

CloudRawRGB loadPCD(const char* cloud_fname,CloudRawRGB::Cloud::Ptr& cloud){
    cloud = CloudRawRGB::Cloud::Ptr(new CloudRawRGB::Cloud());
    pcl::io::loadPCDFile (cloud_fname, *cloud);
    std::vector<int> index;
     // Create the filtering object
    pcl::VoxelGrid<CloudRawRGB::Point> sor;
    sor.setInputCloud (cloud);
    sor.setLeafSize (0.02, 0.02, 0.02);
    sor.filter (*cloud);
    pcl::removeNaNFromPointCloud(*cloud,*cloud,index);
    return CloudRawRGB(*cloud);
}

CloudRawRGB::Cloud::Ptr cloud;
CloudRawRGB cloud_raw;// = loadPCD("/sdcard/cloud.pcd",cloud);

bool setupGraphics(int w, int h) {
    printGLString("Version", GL_VERSION);
    printGLString("Vendor", GL_VENDOR);
    printGLString("Renderer", GL_RENDERER);
    printGLString("Extensions", GL_EXTENSIONS);

    LOGI("setupGraphics(%d, %d)", w, h);
    gProgram = createProgram(gVertexShader, gFragmentShader);
    if (!gProgram) {
        LOGE("Could not create program.");
        return false;
    }
    gvPositionHandle = glGetAttribLocation(gProgram, "a_position");
    checkGlError("glGetAttribLocation");
    gvColorHandle = glGetAttribLocation(gProgram, "a_color");
    checkGlError("glGetAttribLocation");
    gvTransformM = glGetUniformLocation( gProgram, "u_mvpMatrix" );
    checkGlError("glGetUniformLocation");
    LOGI("glGetAttribLocation(\"a_position\") = %d\n",
            gvPositionHandle);
    LOGI("glGetAttribLocation(\"a_color\") = %d\n",
            gvColorHandle);
    LOGI("glGetUniformLocation(\"u_mvpMatri\") = %d\n",
            gvTransformM);

    glViewport(0, 0, w, h);
    camera.setViewport(w,h);
    camera.setFovY(3.14/3);
    AngleAxisf aa(3.14, Vector3f(1,0,0));
    Quaternionf q(aa);
    camera.setOrientation(q);

    camera.setPosition(Vector3f(0, 0, 0));
    //camera.setUp(Vector3f(0, 1, 0));
    camera.setTarget(Vector3f(0, 0, 2.3));
    checkGlError("glViewport");
    
    cloud_raw = CloudRawRGB(loadPCD("/sdcard/cloud.pcd",cloud));
    
    return true;
}

const GLfloat gVertices[] = {  0.5f, -0.5f, 1.0f,
                                     -0.5f, -0.5f, 1.0f,
                                      0.0f, 0.5f, 1.0f};
const GLubyte gColors[] = {255, 0,0,
                          0, 255, 0,
                          0,0, 255};




void renderFrame() {
    glEnable(GL_DEPTH_TEST);
    glDepthRangef (0.1, 100);
    glClearColor(0.0f, 0.0f, 0.1, 1.0f);
    checkGlError("glClearColor");
    glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
    checkGlError("glClear");
       glUseProgram(gProgram);
    if(!cloud_raw.loaded){        
        cloud_raw.loadIntoGLBuffer();
        cloud_raw.loaded = true;
    }
 
    cloud_raw.bind();
        checkGlError("glUseProgram");
        glEnableVertexAttribArray(gvPositionHandle);
        checkGlError("glEnableVertexAttribArray");
        glEnableVertexAttribArray(gvColorHandle);
        checkGlError("glEnableVertexAttribArray");
        glVertexAttribPointer(gvPositionHandle, cloud_raw.PER_V, GL_FLOAT, GL_FALSE, cloud_raw.STEP_V, (void*)0);
        checkGlError("glVertexAttribPointer");
        glVertexAttribPointer(gvColorHandle, cloud_raw.PER_C, GL_UNSIGNED_BYTE, GL_FALSE, 
                              cloud_raw.STEP_C,  (void*)(sizeof(float) * 4));
        checkGlError("glVertexAttribPointer");
        
    static float theta = 0.06;
    AngleAxisf aa(theta, Vector3f(0,1,0));
    Quaternionf q(aa);
  
    camera.rotateAroundTarget(q);
    
   
    
    //theta += 0.01;
    if(theta > 7) theta -= 7;
    Matrix4f pt = camera.projectionMatrix() * camera.viewMatrix().matrix();
    glUniformMatrix4fv (gvTransformM, 1, false, pt.data());
    checkGlError("glUniformMatrix4fv");

    glDrawArrays(GL_POINTS, 0, cloud_raw.n);
    //glDrawArrays(GL_TRIANGLES, 0, cloud_raw.n);
    checkGlError("glDrawArrays");
}

/* DO NOT EDIT THIS FILE - it is machine generated */
/* Header for class com_ros_pcl_hellopcl_GL2JNILib */
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_ros_pcl_hellopcl_GL2JNILib
 * Method:    init
 * Signature: (II)V
 */
JNIEXPORT void JNICALL Java_com_ros_pcl_hellopcl_GL2JNILib_init
  (JNIEnv *, jclass, jint, jint);

/*
 * Class:     com_ros_pcl_hellopcl_GL2JNILib
 * Method:    step
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_ros_pcl_hellopcl_GL2JNILib_step
  (JNIEnv *, jclass);

#ifdef __cplusplus
}
#endif



JNIEXPORT void JNICALL Java_com_ros_pcl_hellopcl_GL2JNILib_init
  (JNIEnv *, jclass, jint width, jint height)
{
    setupGraphics(width, height);
}

JNIEXPORT void JNICALL Java_com_ros_pcl_hellopcl_GL2JNILib_step
  (JNIEnv *, jclass)
{
    renderFrame();
}

---

pcl_android
Author(s): Maintained by Ethan Rublee
autogenerated on Fri Jan 11 09:53:20 2013