264 lines
8.8 KiB
Java
264 lines
8.8 KiB
Java
package de.trac.spherical.rendering;
|
|
|
|
|
|
import android.graphics.Bitmap;
|
|
import android.opengl.GLSurfaceView;
|
|
import android.opengl.GLUtils;
|
|
import android.opengl.Matrix;
|
|
import android.util.Log;
|
|
|
|
import javax.microedition.khronos.egl.EGLConfig;
|
|
import javax.microedition.khronos.opengles.GL10;
|
|
|
|
import static android.opengl.GLES20.*;
|
|
import static android.opengl.GLUtils.getEGLErrorString;
|
|
|
|
public class Renderer implements GLSurfaceView.Renderer {
|
|
|
|
/**
|
|
* Default vertex shader.
|
|
*
|
|
* In: pos
|
|
* uvw
|
|
* Out: uv
|
|
*/
|
|
private static final String DEFAULT_VERTEX_SHADER =
|
|
"uniform mat4 mvpMatrix;\n" +
|
|
"attribute vec3 position;\n" +
|
|
"attribute vec2 textureCoordinates;\n" +
|
|
"varying vec2 uv;\n" +
|
|
"void main() {\n" +
|
|
" gl_Position = mvpMatrix * vec4(position, 1);\n" +
|
|
" uv = textureCoordinates;\n" +
|
|
"}\n";
|
|
|
|
/**
|
|
* Default fragment shader.
|
|
*
|
|
* In: uv
|
|
* Out: sets fragment color
|
|
*/
|
|
private static final String DEFAULT_FRAGMENT_SHADER =
|
|
"varying vec2 uv;\n" +
|
|
"uniform sampler2D tex;\n" +
|
|
"void main() {\n" +
|
|
" gl_FragColor = texture2D(tex, uv);\n" +
|
|
"}\n";
|
|
|
|
// Store a sphere geometry as framework for the photo texture.
|
|
private Sphere sphere = null;
|
|
|
|
// Store projection matrix.
|
|
private float projMatrix [] = new float [16];
|
|
|
|
// Store modelview matrix.
|
|
private float modlMatrix [] = new float [16];
|
|
|
|
// Store view matrix.
|
|
private float viewMatrix [] = new float [16];
|
|
|
|
// Store the model view projection matrix.
|
|
private float mvpMatrix [] = new float [16];
|
|
|
|
// Store shader name.
|
|
private int programID;
|
|
|
|
// Store shader locations.
|
|
private int positionLocation;
|
|
private int textureCoordinatesLocation;
|
|
private int mvpLocation;
|
|
private int texLocation;
|
|
|
|
// Store texture.
|
|
private final int textureID [] = new int[1];
|
|
|
|
// Store bitmap for lazy loading.
|
|
private Bitmap bitmap = null;
|
|
|
|
// Store input handler instance to determine transformation.
|
|
private SphereSurfaceView surfaceView;
|
|
|
|
/**
|
|
* Constructor. Will be set as renderer of the specified surface view.
|
|
* @param surfaceView SurfaceView which will own the renderer
|
|
*/
|
|
public Renderer(SphereSurfaceView surfaceView) {
|
|
if(surfaceView == null)
|
|
throw new NullPointerException("SurfaceView must not be null");
|
|
|
|
this.surfaceView = surfaceView;
|
|
this.surfaceView.setEGLContextClientVersion(2);
|
|
this.surfaceView.setRenderer(this);
|
|
}
|
|
|
|
/**
|
|
* Draws the frame.
|
|
* @param unused unused
|
|
*/
|
|
public void onDrawFrame(GL10 unused) {
|
|
|
|
// Upload texture, if necessary.
|
|
if(bitmap != null) {
|
|
glBindTexture(GL_TEXTURE_2D, textureID[0]);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
GLUtils.texImage2D(GL_TEXTURE_2D, 0, bitmap, 0);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
// Release bitmap for garbage collection.
|
|
bitmap = null;
|
|
}
|
|
|
|
// Update transformation matrix.
|
|
Matrix.multiplyMM(mvpMatrix, 0, surfaceView.getRotationMatrix(), 0, modlMatrix, 0);
|
|
Matrix.multiplyMM(mvpMatrix, 0, projMatrix, 0, mvpMatrix, 0);
|
|
|
|
// Draw the frame.
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
glUseProgram(programID);
|
|
|
|
glEnableVertexAttribArray(positionLocation);
|
|
glVertexAttribPointer(positionLocation, 3, GL_FLOAT, false, 3*4, sphere.getVertexBuffer());
|
|
|
|
glEnableVertexAttribArray(textureCoordinatesLocation);
|
|
glVertexAttribPointer(textureCoordinatesLocation, 2, GL_FLOAT, false, 2*4, sphere.getTextureCoordinatesBuffer());
|
|
|
|
glUniformMatrix4fv(mvpLocation, 1, false, mvpMatrix, 0);
|
|
glUniform1i(texLocation, 0);
|
|
glBindTexture(GL_TEXTURE_2D, textureID[0]);
|
|
glDrawElements(GL_TRIANGLES, sphere.getIndexBuffer().capacity(), GL_UNSIGNED_SHORT, sphere.getIndexBuffer());
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
glDisableVertexAttribArray(textureCoordinatesLocation);
|
|
glDisableVertexAttribArray(positionLocation);
|
|
|
|
glUseProgram(0);
|
|
}
|
|
|
|
/**
|
|
* Callback called if surface changed.
|
|
*
|
|
* @param unused unused
|
|
* @param width new width of the surface
|
|
* @param height new height of the surface
|
|
*/
|
|
public void onSurfaceChanged(GL10 unused, int width, int height) {
|
|
glViewport(0, 0, width, height);
|
|
float ratio = (float) width / height;
|
|
Matrix.perspectiveM(projMatrix, 0, 45.0f, ratio, 0.25f, 128.0f);
|
|
}
|
|
|
|
/**
|
|
* Callback called if surface has been created.
|
|
*
|
|
* @param unused unused
|
|
* @param config surface configuration
|
|
*/
|
|
public void onSurfaceCreated(GL10 unused, EGLConfig config) {
|
|
|
|
// Initialize sphere.
|
|
sphere = new Sphere(10.0f, 32, 32); // TODO: choose useful parameters.
|
|
|
|
// Set OpenGL state.
|
|
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
|
|
glEnable(GL_DEPTH_TEST);
|
|
glEnable(GL_CULL_FACE);
|
|
glFrontFace(GL_CW);
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
// Build shader program.
|
|
programID = buildProgram(DEFAULT_VERTEX_SHADER, DEFAULT_FRAGMENT_SHADER);
|
|
|
|
// Generate texture.
|
|
glGenTextures(1, textureID, 0);
|
|
|
|
// Initialize matrices.
|
|
Matrix.setIdentityM(modlMatrix, 0);
|
|
Matrix.setLookAtM(viewMatrix, 0, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);
|
|
}
|
|
|
|
/**
|
|
* Uploads the image data of the given bitmap into the internal texture.
|
|
* @param bitmap Bitmap to be set as texture
|
|
*/
|
|
public void setBitmap(Bitmap bitmap) {
|
|
this.bitmap = bitmap;
|
|
}
|
|
|
|
/**
|
|
* Builds a shader program given vertex and fragment shader soruce.
|
|
* @param vertexSource The vertex shader source
|
|
* @param fragmentSource The fragment shader source
|
|
* @return shader program
|
|
*/
|
|
private int buildProgram(String vertexSource, String fragmentSource) {
|
|
|
|
int vertexShader = buildShader(GL_VERTEX_SHADER, vertexSource);
|
|
if (vertexShader == 0) {
|
|
throw new RuntimeException("vertex shader could not be loaded");
|
|
}
|
|
|
|
int fragmentShader = buildShader(GL_FRAGMENT_SHADER, fragmentSource);
|
|
if (fragmentShader == 0) {
|
|
throw new RuntimeException("fragment shader could not be loaded");
|
|
}
|
|
|
|
int program = glCreateProgram();
|
|
if (program != 0) {
|
|
glAttachShader(program, vertexShader);
|
|
glAttachShader(program, fragmentShader);
|
|
glLinkProgram(program);
|
|
int[] linkStatus = new int[1];
|
|
glGetProgramiv(program, GL_LINK_STATUS, linkStatus, 0);
|
|
if (linkStatus[0] != GL_TRUE) {
|
|
Log.e("Shader", "Could not link program: ");
|
|
Log.e("Shader", glGetProgramInfoLog(program));
|
|
glDeleteProgram(program);
|
|
throw new RuntimeException("Could not link program");
|
|
}
|
|
}
|
|
|
|
positionLocation = glGetAttribLocation(program, "position");
|
|
if (positionLocation == -1) {
|
|
throw new RuntimeException("Could not get attribute location for 'position'");
|
|
}
|
|
textureCoordinatesLocation = glGetAttribLocation(program, "textureCoordinates");
|
|
if (textureCoordinatesLocation == -1) {
|
|
throw new RuntimeException("Could not get attribute location for 'textureCoordinates'");
|
|
}
|
|
mvpLocation = glGetUniformLocation(program, "mvpMatrix");
|
|
if (mvpLocation == -1) {
|
|
throw new RuntimeException("Could not get uniform location for 'mvpMatrix'");
|
|
}
|
|
texLocation = glGetUniformLocation(program, "tex");
|
|
if(texLocation == -1) {
|
|
throw new RuntimeException("Could not get uniform location for 'tex'");
|
|
}
|
|
|
|
return program;
|
|
}
|
|
|
|
/**
|
|
* Builds a shader of a specified type from a given source.
|
|
* @param type The shader type.
|
|
* @param source The shader source
|
|
* @return shader name
|
|
*/
|
|
private int buildShader(int type, String source) {
|
|
int shader = glCreateShader(type);
|
|
if (shader != 0) {
|
|
glShaderSource(shader, source);
|
|
glCompileShader(shader);
|
|
int[] compiled = new int[1];
|
|
glGetShaderiv(shader, GL_COMPILE_STATUS, compiled, 0);
|
|
if (compiled[0] == 0) {
|
|
Log.e("Shader", "Could not compile shader " + type + ":");
|
|
Log.e("Shader", glGetShaderInfoLog(shader));
|
|
glDeleteShader(shader);
|
|
shader = 0;
|
|
}
|
|
}
|
|
return shader;
|
|
}
|
|
}
|