public circle(float r) {
transMatrix = new float[16];
int sides = 24;
vertexCoords = new float[sides * 3];
double angle = 2 * Math.PI / sides;
for (int i = 0; i < sides; i++) {
vertexCoords[3 * i] = (float) (Math.cos(i * angle) * r);
vertexCoords[3 * i + 1] = (float) (Math.sin(i * angle) * r);
vertexCoords[3 * i + 2] = 0f;
}
vertexCount = vertexCoords.length / COORDS_PER_VERTEX;
vertexStride = COORDS_PER_VERTEX * 4;
ByteBuffer bb = ByteBuffer.allocateDirect(vertexCoords.length * 4);
bb.order(ByteOrder.nativeOrder());
vertexBuffer = bb.asFloatBuffer();
vertexBuffer.put(vertexCoords);
vertexBuffer.position(0);
int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);
mProgram = GLES20.glCreateProgram(); // create empty OpenGL Program
GLES20.glAttachShader(mProgram, vertexShader); // add the vertex shader to program
GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
GLES20.glLinkProgram(mProgram); // create OpenGL program executables
}
public void fellipse(Coord c, Coord r, int a1, int a2) {
st.set(cur2d);
apply();
gl.glBegin(GL.GL_TRIANGLE_FAN);
vertex(c);
for (int i = a1; i <= a2; i += 5) {
double a = (i * Math.PI * 2) / 360.0;
vertex(c.add((int) (Math.cos(a) * r.x), -(int) (Math.sin(a) * r.y)));
}
gl.glEnd();
checkerr();
}
/**
* Computes the vertices of the triangles for rendering a sphere and stores them in _buffer.
* The vertices are repeated as necessary so that the buffer can be used by rendering with
* glDrawArrays.
*/
private void computeVertices() {
final int nphi = 50;
final int ntheta = 100;
final float dphi = (float) Math.PI / nphi;
final float dtheta = 2.0f * (float) Math.PI / ntheta;
float[] vertices = new float[2 * 3 * 3 * ntheta + (nphi - 2) * 3 * 6 * ntheta];
// Precompute trigonometry.
float[] phiSin = new float[nphi];
float[] phiCos = new float[nphi];
for (int i = 0; i < nphi; ++i) {
float phi = i * dphi;
phiSin[i] = (float) Math.sin(phi);
phiCos[i] = (float) Math.cos(phi);
}
float[] thetaSin = new float[ntheta];
float[] thetaCos = new float[ntheta];
for (int i = 0; i < ntheta; ++i) {
float theta = i * dtheta;
thetaSin[i] = (float) Math.sin(theta);
thetaCos[i] = (float) Math.cos(theta);
}
// Fan at north pole.
int index = 0;
for (int i = 0; i < ntheta; ++i) {
// Pole.
vertices[index++] = 0.0f; // x
vertices[index++] = 0.0f; // y
vertices[index++] = 1.0f; // z
vertices[index++] = thetaCos[i] * phiSin[1]; // x
vertices[index++] = thetaSin[i] * phiSin[1]; // y
vertices[index++] = phiCos[1]; // z
int j = (i + 1) % ntheta;
vertices[index++] = thetaCos[j] * phiSin[1];
vertices[index++] = thetaSin[j] * phiSin[1];
vertices[index++] = phiCos[1];
}
// Latitude strips.
for (int ip = 1; ip < nphi - 1; ++ip) {
for (int it = 0; it < ntheta; ++it) {
int jt = (it + 1) % ntheta;
vertices[index++] = thetaCos[it] * phiSin[ip];
vertices[index++] = thetaSin[it] * phiSin[ip];
vertices[index++] = phiCos[ip];
vertices[index++] = thetaCos[it] * phiSin[ip + 1];
vertices[index++] = thetaSin[it] * phiSin[ip + 1];
vertices[index++] = phiCos[ip + 1];
vertices[index++] = thetaCos[jt] * phiSin[ip];
vertices[index++] = thetaSin[jt] * phiSin[ip];
vertices[index++] = phiCos[ip];
vertices[index] = vertices[index - 3];
++index;
vertices[index] = vertices[index - 3];
++index;
vertices[index] = vertices[index - 3];
++index;
vertices[index] = vertices[index - 9];
++index;
vertices[index] = vertices[index - 9];
++index;
vertices[index] = vertices[index - 9];
++index;
vertices[index++] = thetaCos[jt] * phiSin[ip + 1];
vertices[index++] = thetaSin[jt] * phiSin[ip + 1];
vertices[index++] = phiCos[ip + 1];
}
}
// Fan at south pole.
for (int i = 0; i < ntheta; ++i) {
vertices[index++] = thetaCos[i] * phiSin[nphi - 1];
vertices[index++] = thetaSin[i] * phiSin[nphi - 1];
vertices[index++] = phiCos[nphi - 1];
// Pole.
vertices[index++] = 0.0f;
vertices[index++] = 0.0f;
vertices[index++] = 1.0f;
int j = (i + 1) % ntheta;
vertices[index++] = thetaCos[j] * phiSin[nphi - 1];
vertices[index++] = thetaSin[j] * phiSin[nphi - 1];
vertices[index++] = phiCos[nphi - 1];
}
_buffer =
ByteBuffer.allocateDirect(vertices.length * 4)
.order(ByteOrder.nativeOrder())
.asFloatBuffer();
_buffer.put(vertices);
_buffer.rewind();
}