mirror of
https://github.com/vanitasvitae/Spherical
synced 2024-06-17 00:54:52 +02:00
161 lines
5.7 KiB
Java
161 lines
5.7 KiB
Java
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) {
|
|
|
|
final int polyCountXPitch = polyCountX + 1;
|
|
|
|
// Setup vertex buffer.
|
|
ByteBuffer buffer = ByteBuffer.allocateDirect((polyCountXPitch*polyCountY+2)*3*4);
|
|
buffer.order(ByteOrder.nativeOrder());
|
|
vertexBuffer = buffer.asFloatBuffer();
|
|
|
|
// Setup texture coordinate buffer.
|
|
buffer = ByteBuffer.allocateDirect((polyCountXPitch*polyCountY+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();
|
|
|
|
for (int p1 = 0, level = 0; p1 < polyCountY-1; p1++) {
|
|
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));
|
|
}
|
|
|
|
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++) {
|
|
indexBuffer.put((short)(polyCountSq));
|
|
indexBuffer.put((short)(p2 + 1));
|
|
indexBuffer.put((short)(p2));
|
|
|
|
indexBuffer.put((short)(polyCountSqM1 + p2));
|
|
indexBuffer.put((short)(polyCountSqM1 + p2 + 1));
|
|
indexBuffer.put((short)(polyCountSq1));
|
|
}
|
|
|
|
indexBuffer.put((short)(polyCountSq));
|
|
indexBuffer.put((short)(polyCountX));
|
|
indexBuffer.put((short)(polyCountX-1));
|
|
|
|
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;
|
|
final double InvPI = 1.0 / Math.PI;
|
|
|
|
double ay = 0;//AngleY / 2;
|
|
for (int y = 0; y < polyCountY; y++) {
|
|
|
|
ay += AngleY;
|
|
double axz = 0;
|
|
final double sinay = Math.sin(ay);
|
|
final float tv = (float) (ay*InvPI);
|
|
|
|
for (int xz = 0; xz < polyCountX; xz++) {
|
|
|
|
double nx = Math.cos(axz) * sinay;
|
|
double ny = Math.cos(ay);
|
|
double nz = 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 (ny != -1.0 && ny != 1.0)
|
|
tu = (float) (Math.acos(Math.max(Math.min(nx / sinay, 1.0), -1.0)) * 0.5 * InvPI);
|
|
if (nz < 0.0)
|
|
tu = 1.0f - tu;
|
|
} else
|
|
tu = textureCoordinatesBuffer.get(xz*2);
|
|
|
|
vertexBuffer.put((float) (radius * nx));
|
|
vertexBuffer.put((float) (radius * ny));
|
|
vertexBuffer.put((float) (radius * nz));
|
|
textureCoordinatesBuffer.put(tu);
|
|
textureCoordinatesBuffer.put(tv);
|
|
|
|
axz += AngleX;
|
|
}
|
|
|
|
vertexBuffer.put(vertexBuffer.get((y*polyCountXPitch)*3 + 0));
|
|
vertexBuffer.put(vertexBuffer.get((y*polyCountXPitch)*3 + 1));
|
|
vertexBuffer.put(vertexBuffer.get((y*polyCountXPitch)*3 + 2));
|
|
textureCoordinatesBuffer.put(1.0f);
|
|
textureCoordinatesBuffer.put(tv);
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
}
|