gametel 0.1

data/ApiDemos/src/com/example/android/apis/graphics/ShapeDrawable1.java

@@ -0,0 +1,136 @@
+/*
+ * 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.example.android.apis.graphics;
+
+import android.content.Context;
+import android.graphics.*;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.ShapeDrawable;
+import android.graphics.drawable.shapes.*;
+import android.os.Bundle;
+import android.view.*;
+
+public class ShapeDrawable1 extends GraphicsActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(new SampleView(this));
+    }
+
+    private static class SampleView extends View {
+        private ShapeDrawable[] mDrawables;
+
+        private static Shader makeSweep() {
+            return new SweepGradient(150, 25,
+                new int[] { 0xFFFF0000, 0xFF00FF00, 0xFF0000FF, 0xFFFF0000 },
+                null);
+        }
+
+        private static Shader makeLinear() {
+            return new LinearGradient(0, 0, 50, 50,
+                              new int[] { 0xFFFF0000, 0xFF00FF00, 0xFF0000FF },
+                              null, Shader.TileMode.MIRROR);
+        }
+
+        private static Shader makeTiling() {
+            int[] pixels = new int[] { 0xFFFF0000, 0xFF00FF00, 0xFF0000FF, 0};
+            Bitmap bm = Bitmap.createBitmap(pixels, 2, 2,
+                                            Bitmap.Config.ARGB_8888);
+
+            return new BitmapShader(bm, Shader.TileMode.REPEAT,
+                                        Shader.TileMode.REPEAT);
+        }
+
+        private static class MyShapeDrawable extends ShapeDrawable {
+            private Paint mStrokePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+
+            public MyShapeDrawable(Shape s) {
+                super(s);
+                mStrokePaint.setStyle(Paint.Style.STROKE);
+            }
+
+            public Paint getStrokePaint() {
+                return mStrokePaint;
+            }
+
+            @Override protected void onDraw(Shape s, Canvas c, Paint p) {
+                s.draw(c, p);
+                s.draw(c, mStrokePaint);
+            }
+        }
+
+        public SampleView(Context context) {
+            super(context);
+            setFocusable(true);
+
+            float[] outerR = new float[] { 12, 12, 12, 12, 0, 0, 0, 0 };
+            RectF   inset = new RectF(6, 6, 6, 6);
+            float[] innerR = new float[] { 12, 12, 0, 0, 12, 12, 0, 0 };
+
+            Path path = new Path();
+            path.moveTo(50, 0);
+            path.lineTo(0, 50);
+            path.lineTo(50, 100);
+            path.lineTo(100, 50);
+            path.close();
+
+            mDrawables = new ShapeDrawable[7];
+            mDrawables[0] = new ShapeDrawable(new RectShape());
+            mDrawables[1] = new ShapeDrawable(new OvalShape());
+            mDrawables[2] = new ShapeDrawable(new RoundRectShape(outerR, null,
+                                                                 null));
+            mDrawables[3] = new ShapeDrawable(new RoundRectShape(outerR, inset,
+                                                                 null));
+            mDrawables[4] = new ShapeDrawable(new RoundRectShape(outerR, inset,
+                                                                 innerR));
+            mDrawables[5] = new ShapeDrawable(new PathShape(path, 100, 100));
+            mDrawables[6] = new MyShapeDrawable(new ArcShape(45, -270));
+
+            mDrawables[0].getPaint().setColor(0xFFFF0000);
+            mDrawables[1].getPaint().setColor(0xFF00FF00);
+            mDrawables[2].getPaint().setColor(0xFF0000FF);
+            mDrawables[3].getPaint().setShader(makeSweep());
+            mDrawables[4].getPaint().setShader(makeLinear());
+            mDrawables[5].getPaint().setShader(makeTiling());
+            mDrawables[6].getPaint().setColor(0x88FF8844);
+
+            PathEffect pe = new DiscretePathEffect(10, 4);
+            PathEffect pe2 = new CornerPathEffect(4);
+            mDrawables[3].getPaint().setPathEffect(
+                                                new ComposePathEffect(pe2, pe));
+
+            MyShapeDrawable msd = (MyShapeDrawable)mDrawables[6];
+            msd.getStrokePaint().setStrokeWidth(4);
+        }
+
+        @Override protected void onDraw(Canvas canvas) {
+
+            int x = 10;
+            int y = 10;
+            int width = 300;
+            int height = 50;
+
+            for (Drawable dr : mDrawables) {
+                dr.setBounds(x, y, x + width, y + height);
+                dr.draw(canvas);
+                y += height + 5;
+            }
+        }
+    }
+}
+

data/ApiDemos/src/com/example/android/apis/graphics/StaticTriangleRenderer.java

@@ -0,0 +1,274 @@
+/*
+ * Copyright (C) 2008 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.example.android.apis.graphics;
+
+import static android.opengl.GLES10.*;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.nio.ShortBuffer;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.opengl.GLSurfaceView;
+import android.opengl.GLU;
+import android.opengl.GLUtils;
+import android.os.SystemClock;
+
+import com.example.android.apis.R;
+
+/**
+ * A GLSurfaceView.Renderer that uses the Android-specific
+ * android.opengl.GLESXXX static OpenGL ES APIs. The static APIs
+ * expose more of the OpenGL ES features than the
+ * javax.microedition.khronos.opengles APIs, and also
+ * provide a programming model that is closer to the C OpenGL ES APIs, which
+ * may make it easier to reuse code and documentation written for the
+ * C OpenGL ES APIs.
+ *
+ */
+public class StaticTriangleRenderer implements GLSurfaceView.Renderer{
+
+    public interface TextureLoader {
+        /**
+         * Load a texture into the currently bound OpenGL texture.
+         */
+        void load(GL10 gl);
+    }
+
+    public StaticTriangleRenderer(Context context) {
+        init(context, new RobotTextureLoader());
+    }
+
+    public StaticTriangleRenderer(Context context, TextureLoader loader) {
+        init(context, loader);
+    }
+
+    private void init(Context context, TextureLoader loader) {
+        mContext = context;
+        mTriangle = new Triangle();
+        mTextureLoader = loader;
+    }
+
+    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+        /*
+         * By default, OpenGL enables features that improve quality
+         * but reduce performance. One might want to tweak that
+         * especially on software renderer.
+         */
+        glDisable(GL_DITHER);
+
+        /*
+         * Some one-time OpenGL initialization can be made here
+         * probably based on features of this particular context
+         */
+        glHint(GL_PERSPECTIVE_CORRECTION_HINT,
+                GL_FASTEST);
+
+        glClearColor(.5f, .5f, .5f, 1);
+        glShadeModel(GL_SMOOTH);
+        glEnable(GL_DEPTH_TEST);
+        glEnable(GL_TEXTURE_2D);
+
+        /*
+         * Create our texture. This has to be done each time the
+         * surface is created.
+         */
+
+        int[] textures = new int[1];
+        glGenTextures(1, textures, 0);
+
+        mTextureID = textures[0];
+        glBindTexture(GL_TEXTURE_2D, mTextureID);
+
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                GL_NEAREST);
+        glTexParameterf(GL_TEXTURE_2D,
+                GL_TEXTURE_MAG_FILTER,
+                GL_LINEAR);
+
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
+                GL_CLAMP_TO_EDGE);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
+                GL_CLAMP_TO_EDGE);
+
+        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
+                GL_REPLACE);
+        mTextureLoader.load(gl);
+    }
+
+    public void onDrawFrame(GL10 gl) {
+        /*
+         * By default, OpenGL enables features that improve quality
+         * but reduce performance. One might want to tweak that
+         * especially on software renderer.
+         */
+        glDisable(GL_DITHER);
+
+        glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
+                GL_MODULATE);
+
+        /*
+         * Usually, the first thing one might want to do is to clear
+         * the screen. The most efficient way of doing this is to use
+         * glClear().
+         */
+
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        /*
+         * Now we're ready to draw some 3D objects
+         */
+
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+
+        GLU.gluLookAt(gl, 0, 0, -5, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
+
+        glEnableClientState(GL_VERTEX_ARRAY);
+        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+        glActiveTexture(GL_TEXTURE0);
+        glBindTexture(GL_TEXTURE_2D, mTextureID);
+        glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
+                GL_REPEAT);
+        glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
+                GL_REPEAT);
+
+        long time = SystemClock.uptimeMillis() % 4000L;
+        float angle = 0.090f * ((int) time);
+
+        glRotatef(angle, 0, 0, 1.0f);
+
+        mTriangle.draw(gl);
+    }
+
+    public void onSurfaceChanged(GL10 gl, int w, int h) {
+        glViewport(0, 0, w, h);
+
+        /*
+        * Set our projection matrix. This doesn't have to be done
+        * each time we draw, but usually a new projection needs to
+        * be set when the viewport is resized.
+        */
+
+        float ratio = (float) w / h;
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
+        glFrustumf(-ratio, ratio, -1, 1, 3, 7);
+    }
+
+    private Context mContext;
+    private Triangle mTriangle;
+    private int mTextureID;
+    private TextureLoader mTextureLoader;
+
+    private class RobotTextureLoader implements TextureLoader {
+        public void load(GL10 gl) {
+            InputStream is = mContext.getResources().openRawResource(
+                    R.raw.robot);
+            Bitmap bitmap;
+            try {
+                bitmap = BitmapFactory.decodeStream(is);
+            } finally {
+                try {
+                    is.close();
+                } catch (IOException e) {
+                    // Ignore.
+                }
+            }
+
+            GLUtils.texImage2D(GL_TEXTURE_2D, 0, bitmap, 0);
+            bitmap.recycle();
+        }
+    }
+
+    static class Triangle {
+        public Triangle() {
+
+            // Buffers to be passed to gl*Pointer() functions
+            // must be direct, i.e., they must be placed on the
+            // native heap where the garbage collector cannot
+            // move them.
+            //
+            // Buffers with multi-byte datatypes (e.g., short, int, float)
+            // must have their byte order set to native order
+
+            ByteBuffer vbb = ByteBuffer.allocateDirect(VERTS * 3 * 4);
+            vbb.order(ByteOrder.nativeOrder());
+            mFVertexBuffer = vbb.asFloatBuffer();
+
+            ByteBuffer tbb = ByteBuffer.allocateDirect(VERTS * 2 * 4);
+            tbb.order(ByteOrder.nativeOrder());
+            mTexBuffer = tbb.asFloatBuffer();
+
+            ByteBuffer ibb = ByteBuffer.allocateDirect(VERTS * 2);
+            ibb.order(ByteOrder.nativeOrder());
+            mIndexBuffer = ibb.asShortBuffer();
+
+            // A unit-sided equilateral triangle centered on the origin.
+            float[] coords = {
+                    // X, Y, Z
+                    -0.5f, -0.25f, 0,
+                     0.5f, -0.25f, 0,
+                     0.0f,  0.559016994f, 0
+            };
+
+            for (int i = 0; i < VERTS; i++) {
+                for(int j = 0; j < 3; j++) {
+                    mFVertexBuffer.put(coords[i*3+j] * 2.0f);
+                }
+            }
+
+            for (int i = 0; i < VERTS; i++) {
+                for(int j = 0; j < 2; j++) {
+                    mTexBuffer.put(coords[i*3+j] * 2.0f + 0.5f);
+                }
+            }
+
+            for(int i = 0; i < VERTS; i++) {
+                mIndexBuffer.put((short) i);
+            }
+
+            mFVertexBuffer.position(0);
+            mTexBuffer.position(0);
+            mIndexBuffer.position(0);
+        }
+
+        public void draw(GL10 gl) {
+            glFrontFace(GL_CCW);
+            glVertexPointer(3, GL_FLOAT, 0, mFVertexBuffer);
+            glEnable(GL_TEXTURE_2D);
+            glTexCoordPointer(2, GL_FLOAT, 0, mTexBuffer);
+            glDrawElements(GL_TRIANGLE_STRIP, VERTS,
+                    GL_UNSIGNED_SHORT, mIndexBuffer);
+        }
+
+        private final static int VERTS = 3;
+
+        private FloatBuffer mFVertexBuffer;
+        private FloatBuffer mTexBuffer;
+        private ShortBuffer mIndexBuffer;
+    }
+}

data/ApiDemos/src/com/example/android/apis/graphics/SurfaceViewOverlay.java

@@ -0,0 +1,116 @@
+/*
+ * 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.example.android.apis.graphics;
+
+import android.app.Activity;
+import android.opengl.GLSurfaceView;
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+
+//Need the following import to get access to the app resources, since this
+//class is in a sub-package.
+import com.example.android.apis.R;
+
+/**
+ * Demonstration of overlays placed on top of a SurfaceView.
+ */
+public class SurfaceViewOverlay extends Activity {
+    View mVictimContainer;
+    View mVictim1;
+    View mVictim2;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.surface_view_overlay);
+
+        GLSurfaceView glSurfaceView =
+            (GLSurfaceView) findViewById(R.id.glsurfaceview);
+        glSurfaceView.setRenderer(new CubeRenderer(false));
+
+        // Find the views whose visibility will change
+        mVictimContainer = findViewById(R.id.hidecontainer);
+        mVictim1 = findViewById(R.id.hideme1);
+        mVictim1.setOnClickListener(new HideMeListener(mVictim1));
+        mVictim2 = findViewById(R.id.hideme2);
+        mVictim2.setOnClickListener(new HideMeListener(mVictim2));
+
+        // Find our buttons
+        Button visibleButton = (Button) findViewById(R.id.vis);
+        Button invisibleButton = (Button) findViewById(R.id.invis);
+        Button goneButton = (Button) findViewById(R.id.gone);
+
+        // Wire each button to a click listener
+        visibleButton.setOnClickListener(mVisibleListener);
+        invisibleButton.setOnClickListener(mInvisibleListener);
+        goneButton.setOnClickListener(mGoneListener);
+    }
+
+    @Override
+    protected void onResume() {
+        // Ideally a game should implement onResume() and onPause()
+        // to take appropriate action when the activity looses focus
+        super.onResume();
+    }
+
+    @Override
+    protected void onPause() {
+        // Ideally a game should implement onResume() and onPause()
+        // to take appropriate action when the activity looses focus
+        super.onPause();
+    }
+
+    class HideMeListener implements OnClickListener {
+        final View mTarget;
+
+        HideMeListener(View target) {
+            mTarget = target;
+        }
+
+        public void onClick(View v) {
+            mTarget.setVisibility(View.INVISIBLE);
+        }
+
+    }
+
+    OnClickListener mVisibleListener = new OnClickListener() {
+        public void onClick(View v) {
+            mVictim1.setVisibility(View.VISIBLE);
+            mVictim2.setVisibility(View.VISIBLE);
+            mVictimContainer.setVisibility(View.VISIBLE);
+        }
+    };
+
+    OnClickListener mInvisibleListener = new OnClickListener() {
+        public void onClick(View v) {
+            mVictim1.setVisibility(View.INVISIBLE);
+            mVictim2.setVisibility(View.INVISIBLE);
+            mVictimContainer.setVisibility(View.INVISIBLE);
+        }
+    };
+
+    OnClickListener mGoneListener = new OnClickListener() {
+        public void onClick(View v) {
+            mVictim1.setVisibility(View.GONE);
+            mVictim2.setVisibility(View.GONE);
+            mVictimContainer.setVisibility(View.GONE);
+        }
+    };
+}