auto import from //depot/cupcake/@135843

samples/GlobalTime/src/com/android/globaltime/LatLongSphere.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2007 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.
+ */
+
+package com.android.globaltime;
+
+public class LatLongSphere extends Sphere {
+
+    public LatLongSphere(float centerX, float centerY, float centerZ,
+        float radius, int lats, int longs,
+        float minLongitude, float maxLongitude,
+        boolean emitTextureCoordinates,
+        boolean emitNormals,
+        boolean emitColors,
+        boolean flatten) {
+        super(emitTextureCoordinates, emitNormals, emitColors);
+
+        int tris = 2 * (lats - 1) * (longs - 1);
+        int[] vertices = new int[3 * lats * longs];
+        int[] texcoords = new int[2 * lats * longs];
+        int[] colors = new int[4 * lats * longs];
+        int[] normals = new int[3 * lats * longs];
+        short[] indices = new short[3 * tris];
+
+        int vidx = 0;
+        int tidx = 0;
+        int nidx = 0;
+        int cidx = 0;
+        int iidx = 0;
+
+        minLongitude *= DEGREES_TO_RADIANS;
+        maxLongitude *= DEGREES_TO_RADIANS;
+
+        for (int i = 0; i < longs; i++) {
+            float fi = (float) i / (longs - 1);
+            // theta is the longitude
+            float theta =
+                (maxLongitude - minLongitude) * (1.0f - fi) + minLongitude;
+            float sinTheta = (float) Math.sin(theta);
+            float cosTheta = (float) Math.cos(theta);
+
+            for (int j = 0; j < lats; j++) {
+                float fj = (float) j / (lats - 1);
+                // phi is the latitude
+                float phi = PI * fj;
+                float sinPhi = (float) Math.sin(phi);
+                float cosPhi = (float) Math.cos(phi);
+                float x = cosTheta * sinPhi;
+                float y = cosPhi;
+                float z = sinTheta * sinPhi;
+
+                if (flatten) {
+                    // Place vertices onto a flat projection
+                    vertices[vidx++] = toFixed(2.0f * fi - 1.0f);
+                    vertices[vidx++] = toFixed(0.5f - fj);
+                    vertices[vidx++] = toFixed(0.0f);
+                } else {
+                    // Place vertices onto the surface of a sphere
+                    // with the given center and radius
+                    vertices[vidx++] = toFixed(x * radius + centerX);
+                    vertices[vidx++] = toFixed(y * radius + centerY);
+                    vertices[vidx++] = toFixed(z * radius + centerZ);
+                }
+
+                if (emitTextureCoordinates) {
+                    texcoords[tidx++] = toFixed(1.0f - (theta / (TWO_PI)));
+                    texcoords[tidx++] = toFixed(fj);
+                }
+
+                if (emitNormals) {
+                    float norm = 1.0f / Shape.length(x, y, z);
+                    normals[nidx++] = toFixed(x * norm);
+                    normals[nidx++] = toFixed(y * norm);
+                    normals[nidx++] = toFixed(z * norm);
+                }
+
+                // 0 == black, 65536 == white
+                if (emitColors) {
+                    colors[cidx++] = (i % 2) * 65536;
+                    colors[cidx++] = 0;
+                    colors[cidx++] = (j % 2) * 65536;
+                    colors[cidx++] = 65536;
+                }
+            }
+        }
+
+        for (int i = 0; i < longs - 1; i++) {
+            for (int j = 0; j < lats - 1; j++) {
+                int base = i * lats + j;
+
+                // Ensure both triangles have the same final vertex
+                // since this vertex carries the color for flat
+                // shading
+                indices[iidx++] = (short) (base);
+                indices[iidx++] = (short) (base + 1);
+                indices[iidx++] = (short) (base + lats + 1);
+
+                indices[iidx++] = (short) (base + lats);
+                indices[iidx++] = (short) (base);
+                indices[iidx++] = (short) (base + lats + 1);
+            }
+        }
+        
+        allocateBuffers(vertices, texcoords, normals, colors, indices);
+    }
+}