vanitasvitae
/
Spherical
mirror of https://github.com/vanitasvitae/Spherical
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Add first revision of sphere rendering

feature_fragments
Simon Leistikow 5 years ago
parent
1e689b6d46
commit
203ee1e1af
5 changed files with 420 additions and 8 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      app/build.gradle
  2. 8
      app/src/main/java/de/trac/spherical/MainActivity.java
  3. 224
      app/src/main/java/de/trac/spherical/rendering/Renderer.java
  4. 180
      app/src/main/java/de/trac/spherical/rendering/Sphere.java
  5. 8
      app/src/main/res/layout/activity_main.xml

8
app/build.gradle
Unescape View File

@ -1,12 +1,12 @@
apply plugin: 'com.android.application'
android {
compileSdkVersion 26
buildToolsVersion "26.0.1"
compileSdkVersion 25
buildToolsVersion "25.0.3"
defaultConfig {
applicationId "de.trac.spherical"
minSdkVersion 15
targetSdkVersion 26
targetSdkVersion 25
versionCode 1
versionName "1.0"
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
@ -24,7 +24,7 @@ dependencies {
androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
exclude group: 'com.android.support', module: 'support-annotations'
})
compile 'com.android.support:appcompat-v7:26.+'
compile 'com.android.support:appcompat-v7:25.+'
compile 'com.android.support.constraint:constraint-layout:1.0.2'
testCompile 'junit:junit:4.12'
}

8
app/src/main/java/de/trac/spherical/MainActivity.java
Unescape View File

@ -1,13 +1,21 @@
package de.trac.spherical;
import android.opengl.GLSurfaceView;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import de.trac.spherical.rendering.Renderer;
public class MainActivity extends AppCompatActivity {
private GLSurfaceView surfaceView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
surfaceView = (GLSurfaceView) findViewById(R.id.surface_view);
surfaceView.setEGLContextClientVersion(2);
surfaceView.setRenderer(new Renderer());
}
}

224
app/src/main/java/de/trac/spherical/rendering/Renderer.java
Unescape View File

@ -0,0 +1,224 @@
package de.trac.spherical.rendering;
import android.database.MatrixCursor;
import android.opengl.GLSurfaceView;
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.*;
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 =
"precision mediump float;\n" +
"varying vec2 uv;\n" +
"uniform sampler2D tex;\n" +
"void main() {\n" +
" gl_FragColor = vec4(0);//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;
/**
* Draws the frame.
* @param unused unused
*/
public void onDrawFrame(GL10 unused) {
// Update transformation matrix.
Matrix.multiplyMM(mvpMatrix, 0, viewMatrix, 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);
glDrawElements(GL_TRIANGLES, sphere.getIndexBuffer().capacity(), GL_UNSIGNED_SHORT, sphere.getIndexBuffer());
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
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();
//TODO: (re)move tmp code
Matrix.setIdentityM(modlMatrix, 0);
Matrix.translateM(modlMatrix, 0, 0, 0, 4.0f);
Matrix.setLookAtM(viewMatrix, 0, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);
}
/**
* Initialize OpenGL state and data.
*/
public void initialize() {
// Initialize sphere.
sphere = new Sphere(1.0f, 32, 32); // TODO: choose useful aparameters.
// Set OpenGL state.
glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
// Build shader program.
programID = buildProgram(DEFAULT_VERTEX_SHADER, DEFAULT_FRAGMENT_SHADER);
}
/**
* Reset OpenGL state and delete data.
*/
public void deinitialize() {
sphere = null;
glDeleteProgram(programID);
}
/**
* 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'");
}
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;
}
}

180
app/src/main/java/de/trac/spherical/rendering/Sphere.java
Unescape View File

@ -0,0 +1,180 @@
package de.trac.spherical.rendering;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
/**
* This class is used to create native buffers holding vertices and
* texture coordinates of a sphere with a given radius.
*/
public class Sphere {
// The following attributes make up our sphere.
private FloatBuffer vertexBuffer;
private FloatBuffer textureCoordinatesBuffer;
private ShortBuffer indexBuffer;
public Sphere(float radius, int polyCountX, int polyCountY) {
// Setup vertex buffer.
ByteBuffer buffer = ByteBuffer.allocateDirect((polyCountX*polyCountY+2)*2*3*4);
buffer.order(ByteOrder.nativeOrder());
vertexBuffer = buffer.asFloatBuffer();
// Setup texture coordinate buffer.
buffer = ByteBuffer.allocateDirect((polyCountX*polyCountY+2)*2*2*4);
buffer.order(ByteOrder.nativeOrder());
textureCoordinatesBuffer = buffer.asFloatBuffer();
// Setup index buffer.
buffer = ByteBuffer.allocateDirect(polyCountX*polyCountY*6*2);
buffer.order(ByteOrder.nativeOrder());
indexBuffer = buffer.asShortBuffer();
int polyCountXPitch = polyCountX+1; // get to same vertex on next level
int level = 0;
for (int p1 = 0; p1 < polyCountY-1; p1++) {
//main quads, top to bottom
for (int p2 = 0; p2 < polyCountX - 1; p2++)
{
final int curr = level + p2;
indexBuffer.put((short)(curr + polyCountXPitch));
indexBuffer.put((short)(curr));
indexBuffer.put((short)(curr + 1));
indexBuffer.put((short)(curr + polyCountXPitch));
indexBuffer.put((short)(curr+1));
indexBuffer.put((short)(curr + 1 + polyCountXPitch));
}
// the connectors from front to end
indexBuffer.put((short)(level + polyCountX - 1 + polyCountXPitch));
indexBuffer.put((short)(level + polyCountX - 1));
indexBuffer.put((short)(level + polyCountX));
indexBuffer.put((short)(level + polyCountX - 1 + polyCountXPitch));
indexBuffer.put((short)(level + polyCountX));
indexBuffer.put((short)(level + polyCountX + polyCountXPitch));
level += polyCountXPitch;
}
final int polyCountSq = polyCountXPitch * polyCountY; // top point
final int polyCountSq1 = polyCountSq + 1; // bottom point
final int polyCountSqM1 = (polyCountY - 1) * polyCountXPitch; // last row's first vertex
for (int p2 = 0; p2 < polyCountX - 1; p2++) {
// create triangles which are at the top of the sphere
indexBuffer.put((short)(polyCountSq));
indexBuffer.put((short)(p2 + 1));
indexBuffer.put((short)(p2));
// create triangles which are at the bottom of the sphere
indexBuffer.put((short)(polyCountSqM1 + p2));
indexBuffer.put((short)(polyCountSqM1 + p2 + 1));
indexBuffer.put((short)(polyCountSq1));
}
// create final triangle which is at the top of the sphere
indexBuffer.put((short)(polyCountSq));
indexBuffer.put((short)(polyCountX));
indexBuffer.put((short)(polyCountX-1));
// create final triangle which is at the bottom of the sphere
indexBuffer.put((short)(polyCountSqM1 + polyCountX - 1));
indexBuffer.put((short)(polyCountSqM1));
indexBuffer.put((short)(polyCountSq1));
// calculate the angle which separates all points in a circle
final double AngleX = 2.0 * Math.PI / polyCountX;
final double AngleY = Math.PI / polyCountY;
int i=0;
double axz;
// we don't start at 0.
double ay = 0;//AngleY / 2;
for (int y = 0; y < polyCountY; y++) {
ay += AngleY;
final double sinay = Math.sin(ay);
axz = 0;
// calculate the necessary vertices without the doubled one
for (int xz = 0; xz < polyCountX; xz++)
{
float rx = (float) (radius * Math.cos(axz) * sinay);
float ry = (float) (radius * Math.cos(ay));
float rz = (float) (radius * Math.sin(axz) * sinay);
// calculate texture coordinates via sphere mapping
// tu is the same on each level, so only calculate once
float tu = 0.5f;
if (y==0)
{
if (ry != -1.0f && ry != 1.0f) {
float len = (float) Math.sqrt(rx*rx + ry*ry + rz*rz);
tu = (float) (Math.acos(Math.max(Math.min(rx / len / sinay, 1.0), -1.0)) * 0.5 / Math.PI);
}
if (rz < 0.0f)
tu=1-tu;
}
else
tu = textureCoordinatesBuffer.get((i-polyCountXPitch)*2);
vertexBuffer.put(rx);
vertexBuffer.put(ry);
vertexBuffer.put(rz);
textureCoordinatesBuffer.put(tu);
textureCoordinatesBuffer.put((float)(ay/Math.PI));
i++;
axz += AngleX;
}
// This is the doubled vertex on the initial position
vertexBuffer.put(vertexBuffer.get((i-polyCountX)*3 + 0));
vertexBuffer.put(vertexBuffer.get((i-polyCountX)*3 + 1));
vertexBuffer.put(vertexBuffer.get((i-polyCountX)*3 + 2));
textureCoordinatesBuffer.put(1.0f);
textureCoordinatesBuffer.put(0.0f);
i++;
}
// Add the vertex at the top of the sphere.
vertexBuffer.put(0.0f);
vertexBuffer.put(radius);
vertexBuffer.put(0.0f);
textureCoordinatesBuffer.put(0.5f);
textureCoordinatesBuffer.put(0.0f);
// Add the vertex at the bottom of the sphere.
vertexBuffer.put(0.0f);
vertexBuffer.put(-radius);
vertexBuffer.put(0.0f);
textureCoordinatesBuffer.put(0.5f);
textureCoordinatesBuffer.put(1.0f);
// Rewind buffers.
vertexBuffer.position(0);
textureCoordinatesBuffer.position(0);
indexBuffer.position(0);
}
public FloatBuffer getVertexBuffer() {
return vertexBuffer;
}
public FloatBuffer getTextureCoordinatesBuffer() {
return textureCoordinatesBuffer;
}
public ShortBuffer getIndexBuffer() {
return indexBuffer;
}
}

8
app/src/main/res/layout/activity_main.xml
Unescape View File

@ -6,10 +6,10 @@
android:layout_height="match_parent"
tools:context="de.trac.spherical.MainActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!"
<android.opengl.GLSurfaceView
android:id="@+id/surface_view"
android:layout_width="match_parent"
android:layout_height="match_parent"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"

Write Preview
Loading…
Cancel
Save