android画三角形

1. android进行萤幕上图画 点和点之间画线

Android画笔里里是可以设置断断续续的风格的，可是你的代码里没有设置，估计就是你模拟器的问题了

2. 如何使用Android中的OpenGL ES媒体效果

Android的媒体效果框架允许开发者可以很容易的应用多种令人印象深刻的视觉效果到照片或视频之上。作为这个媒体效果的框架，它使用GPU来处理图片处理的过程，它仅仅接收OpenGL的纹理（texture）作为输入。在本次教程中，你将会学习到如何使用OpenGL ES2.0将图片资源转化为纹理，以及如何使用框架为图片应用不同的处理效果。
准备
为了开始本次的教程，你必须具备：
1.一款支持Android开发的IDE，如果你没有的话，可以在Android Developer website下载最新版本的Android studio。
2.一款运行Android4.0之上Android手机，并且GPU支持OpenGL ES2.0
3.对OpenGL的基本知识了解
设置OpenGL ES环境
创建GLSurfaceView
为了显示OpenGL的图形，你需要使用GLSurfaceView类，就像其他任何的View子类意义，你可以将它添加到你的Activity或Fragment之上，通过在布局xml文件中定义或者在代码中创建实例。
在本次的教程中，我们使用GLSurfaceView作为唯一的View在我们的Activity中，因此，为了简便，我们在代码中创建GLSurfaceView的实例并将其传入setContentView中，这样它将会填充你的整个手机屏幕。Activity中的onCreate方法如下：
<code class="hljs" java="">protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

GLSurfaceView view = new GLSurfaceView(this);
setContentView(view);
}</code>

因为媒体效果的框架仅仅支持OpenGL ES2.0及以上的版本，所以在setEGLContextClientVersion 方法中传入2；
<code avrasm="" class="hljs">view.setEGLContextClientVersion(2);</code>

为了确保GLSurfaceView仅仅在必要的时候进行渲染，我们在setRenderMode 方法中进行设置：
<code avrasm="" class="hljs">view.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);</code>

创建Renderer
Renderer负责渲染GLSurfaceView中的内容。
创建类实现接口GLSurfaceView.Renderer，在这里我们打算将这个类命名为EffectsRenderer，添加构造函数并覆写接口中的抽象方法，如下：
<code class="hljs" java="">public class EffectsRenderer implements GLSurfaceView.Renderer {

public EffectsRenderer(Context context){
super();
}

@Override
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
}

@Override
public void onSurfaceChanged(GL10 gl, int width, int height) {
}

@Override
public void onDrawFrame(GL10 gl) {
}
}</code>

回到Activity中调用setRenderer方法，让GLSurfaceView使用我们创建的Renderer：
<code class="hljs" cs="">view.setRenderer(new EffectsRenderer(this));</code>

编写Manifest文件
如果你想要发布你的App到谷歌商店，在AndroidManifest.xml文件中添加如下语句：
<code class="hljs" xml=""><uses-feature android:glesversion="0x00020000" android:required="true"></uses-feature></code>

这会确保你的app只能被安装在支持OpenGL ES2.0的设备之上。现在OpenGL环境准备完毕。
创建一个OpenGL平面
定义顶点
GLSurfaceView是不能直接显示一张照片的，照片首先应该被转化为纹理，应用在OpenGL square之上。在本次教程中，我将创建一个2D平面，并且具有4个顶点。为了简单，我将使用一个长方形，现在，创建一个新的类Square，用它来代表形状。
<code class="hljs" cs="">public class Square {

}</code>

默认的OpenGL系统的坐标系中的原点是在中心，因此4个角的坐标可以表示为：
左下角： (-1, -1) 右下角：(1, -1) 右上角：(1, 1) 左上角：(-1, 1)
我们使用OpenGL绘制的所有的物体都应该是由三角形决定的，为了画一个方形，我们需要两个具有一条公共边的三角形，那意味着这些三角形的坐标应该是：
triangle 1: (-1, -1), (1, -1), 和 (-1, 1) triangle 2: (1, -1), (-1, 1), 和 (1, 1)
创建一个float数组来代表这些顶点：
<code class="hljs" cpp="">private float vertices[] = {
-1f, -1f,
1f, -1f,
-1f, 1f,
1f, 1f,
};</code>
为了在square上定位纹理，需要确定纹理的顶点坐标，创建另一个数组来表示纹理顶点的坐标：
<code class="hljs" cpp="">private float textureVertices[] = {
0f,1f,
1f,1f,
0f,0f,
1f,0f
};</code>
创建缓冲区
这些坐标数组应该被转变为缓冲字符（byte buffer）在OpenGL可以使用之前，接下来进行定义：
<code class="hljs" cs="">private FloatBuffer verticesBuffer;
private FloatBuffer textureBuffer;</code>
在initializeBuffers方法中去初始化这些缓冲区：使用ByteBuffer.allocateDirect来创建缓冲区，因为float是4个字节，那么我们需要的byte数组的长度应该为float的4倍。
下面使用ByteBuffer.nativeOrder方法来定义在底层的本地平台上的byte的顺序。使用asFloatBuffer方法将ByteBuffer转化为FloatBuffer，在FloatBuffer被创建后，我们调用put方法来将float数组放入缓冲区，最后，调用position方法来保证我们是由缓冲区的开头进行读取。
<code avrasm="" class="hljs">private void initializeBuffers(){
ByteBuffer buff = ByteBuffer.allocateDirect(vertices.length * 4);
buff.order(ByteOrder.nativeOrder());
verticesBuffer = buff.asFloatBuffer();
verticesBuffer.put(vertices);
verticesBuffer.position(0);

buff = ByteBuffer.allocateDirect(textureVertices.length * 4);
buff.order(ByteOrder.nativeOrder());
textureBuffer = buff.asFloatBuffer();
textureBuffer.put(textureVertices);
textureBuffer.position(0);
}</code>
创建着色器
着色器只不过是简单的运行在GPU中的每个单独的顶点的C程序，在本次教程中，我们使用两种着色器：顶点着色器和片段着色器。
顶点着色器的代码：
<code class="hljs" glsl="">attribute vec4 aPosition;
attribute vec2 aTexPosition;
varying vec2 vTexPosition;
void main() {
gl_Position = aPosition;
vTexPosition = aTexPosition;
};</code>
片段着色器的代码
class="hljs" glsl="">precision mediump float;

uniform sampler2D uTexture;
varying vec2 vTexPosition;
void main() {
gl_FragColor = texture2D(uTexture, vTexPosition);
};</code>
如果你了解OpenGL，那么这段代码对你来说是熟悉的，如果你不能理解这段代码，你可以参考OpenGL documentation。这里有一个简明扼要的解释：
顶点着色器负责绘制单个顶点。aPosition是一个变量被绑定到FloatBuffer上，包含着这些顶点的坐标。相似的，aTexPosition 是一个变量被绑定到FloatBuffer上，包含着纹理的坐标。gl_Position 是一个在OpenGL中创建的变量，代表每一个顶点的位置，vTexPosition是一个数组变量，它的值被传递到片段着色器中。
在本教程中，片段着色器负责square的着色。它使用texture2D方法从纹理中拾取颜色，并且使用一个在OpenGL中被创建的变量gl_FragColor将颜色分配到片段。
在该类中，着色器的代码应该被转化为String。
<code class="hljs" java="">private final String vertexShaderCode =
attribute vec4 aPosition; +
attribute vec2 aTexPosition; +
varying vec2 vTexPosition; +
void main() { +
gl_Position = aPosition; +
vTexPosition = aTexPosition; +
};

private final String fragmentShaderCode =
precision mediump float; +
uniform sampler2D uTexture; +
varying vec2 vTexPosition; +
void main() { +
gl_FragColor = texture2D(uTexture, vTexPosition); +
};</code>
创建程序
创建新的方法initializeProgram来创建一个编译和链接着色器的OpenGL程序。
使用glCreateShader创建一个着色器对象，并且返回以int为表示形式的指针。为了创建顶点着色器，传递GL_VERTEX_SHADER给它。相似的，为了创建一个片段着色器，传递GL_FRAGMENT_SHADER给它。下面使用glShaderSource方法关联相对应的着色器代码到着色器上。使用glCompileShader编译着色器代码。
在编译了着色器的代码后，创建一段新的的程序glCreateProgram，与glCreateShader相似，它也返回一个以int为表示形式的指针。调用glAttachShader方法附着着色器到程序中，最后，调用glLinkProgram进行链接。
代码：
<code class="hljs" cs="">private int vertexShader;
private int fragmentShader;
private int program;
private void initializeProgram(){
vertexShader = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER);
GLES20.glShaderSource(vertexShader, vertexShaderCode);
GLES20.glCompileShader(vertexShader);
fragmentShader = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER);
GLES20.glShaderSource(fragmentShader, fragmentShaderCode);
GLES20.glCompileShader(fragmentShader);
program = GLES20.glCreateProgram();
GLES20.glAttachShader(program, vertexShader);
GLES20.glAttachShader(program, fragmentShader);

GLES20.glLinkProgram(program);
}</code>
你可能会发现，OpenGL的方法（以gl开头的）都是在GLES20类中，这是因为我们使用的是OpenGL ES2.0，如果我们使用更高的版本，就会用到这些类：GLES30，GLES31。
画出形状
现在定义draw方法来利用我们之前定义的点和着色器进行绘制。
下面是你需要做的：
1.使用glBindFramebuffer方法创建一个帧缓冲对象（FBO）
2.调用glUseProgram创建程序，就像之前所提
3.传递GL_BLEND给glDisable方法，在渲染过程中禁用颜色的混合。
4.调用glGetAttribLocation得到变量aPosition和aTexPosition的句柄
5.使用glVertexAttribPointer连接aPosition和aTexPosition的句柄到各自的verticesBuffer和textureBuffer
6.使用glBindTexture方法绑定纹理（作为draw方法的参数传入）到片段着色器上
7.调用glClear方法清空GLSurfaceView的内容
8.最后，使用glDrawArrays方法画出两个三角形（也就是方形）
代码：
<code avrasm="" class="hljs">public void draw(int texture){
GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
GLES20.glUseProgram(program);
GLES20.glDisable(GLES20.GL_BLEND);

int positionHandle = GLES20.glGetAttribLocation(program, aPosition);
int textureHandle = GLES20.glGetUniformLocation(program, uTexture);
int texturePositionHandle = GLES20.glGetAttribLocation(program, aTexPosition);

GLES20.glVertexAttribPointer(texturePositionHandle, 2, GLES20.GL_FLOAT, false, 0, textureBuffer);
GLES20.glEnableVertexAttribArray(texturePositionHandle);

GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texture);
GLES20.glUniform1i(textureHandle, 0);

GLES20.glVertexAttribPointer(positionHandle, 2, GLES20.GL_FLOAT, false, 0, verticesBuffer);
GLES20.glEnableVertexAttribArray(positionHandle);

GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
}</code>

在构造函数中添加初始化方法：
<code class="hljs" cs="">public Square(){
initializeBuffers();
initializeProgram();
}</code>

渲染OpenGL平面和纹理
现在我们的渲染器什么也没做，我们需要改变它来渲染我们在前面创造的平面。
首先，让我们创建一个Bitmap，添加一张照片到res/drawable文件夹之下，我把它命名为forest.jpg,使用BitmapFactory将照片转化为Bitmap。另外将照片的尺寸存储下来。
改变EffectsRenderer的构造函数如下，

<code class="hljs" java="">private Bitmap photo;
private int photoWidth, photoHeight;
public EffectsRenderer(Context context){
super();
photo = BitmapFactory.decodeResource(context.getResources(), R.drawable.forest);
photoWidth = photo.getWidth();
photoHeight = photo.getHeight();
}</code>

创建一个新的方法generateSquare，将Bitmap转化为纹理，并且出初始化Square对象，你也需要一个数组来保存对纹理的引用，使用glGenTextures来初始化这个数组，glBindTexture方法来在位置0激活纹理。
现在，调用glTexParameteri设置不同的级别，决定纹理被怎样渲染。
设置GL_TEXTURE_MIN_FILTER（修正功能），GL_TEXTURE_MAG_FILTER（放大功能）给GL_LINEAR，确保图片是平滑的在它被拉伸的时候。
设置GL_TEXTURE_WRAP_S和GL_TEXTURE_WRAP_T给GL_CLAMP_TO_EDGE，保证纹理不会重复。
最后调用texImage2D方法将Bitmap放置到纹理中，实现方法如下：
<code avrasm="" class="hljs">private int textures[] = new int[2];
private Square square;

private void generateSquare(){
GLES20.glGenTextures(2, textures, 0);
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textures[0]);

GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);

GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, photo, 0);
square = new Square();
}</code>

当GLSurfaceView的尺寸发生改变时，onSurfaceChanged方法被调用，这时我们需要调用glViewPort确认新的尺寸。调用glClearColor使其变为黑色，接着调用generateSquare重新初始化纹理和平面。
<code class="hljs" java="">@Override
public void onSurfaceChanged(GL10 gl, int width, int height) {
GLES20.glViewport(0,0,width, height);
GLES20.glClearColor(0,0,0,1);
generateSquare();
}</code>

最后在onDrawFrame调用draw方法：
<code class="hljs" java="">@Override
public void onDrawFrame(GL10 gl) {
square.draw(textures[0]);
}</code>

3. android 简单的贴图方法，有个小问题！在线等！

简单说就是： 第一种你用系统的控件ImageView去展示图片，第二种就是你自己去实现ImageView这个控件，然后展示这个图片。ImageView是继承自View的，如果ImageView能满足你的需求，可以直接用。如果你有特殊的需求，比如你要自己画一个三角形，不用图片。这样这能自己去画。

4. 在android中怎么至上而下渐变

这个是输出一层颜色渐变的效果，而你的是多层的，做法一样，弄几个小的的三角形同样的画法画到上面。而颜色的值是不可能是线性的值，你只能自己定义每层三角形的颜色，这个是你要做的。 这个我直接用NDK自带的HELLO-GL2给你弄的，就设置下三角形

5. Android OpenGLES3绘图 - 帧缓冲

普通的OpenGL绘图时是绘制到当前帧上面，由于GL环境跟当前屏幕进行了关联，也就直接绘制到屏幕了。这样有两个问题：1. 如果有的帧计算得快，有的计算得慢，而屏幕刷新率是固定的，就会拖慢整体帧率；2. 在着色器里面只能处理当前位置的点，没办法处理当前点跟其他点的关系。

如果将OpenGL计算后的帧缓存起来，不直接绘制。那么就可以利用双缓冲或多缓冲技术稳定帧率；在着色器里面可以从缓存帧读取所有点，就可以进行一些相对位置处理，比如将当前点跟周围点颜色计算平均值，进行图像模糊。这就是帧缓冲。

给一个普通的绘制添加帧缓冲也很方便，基本不影响原来的绘制。假设原来绘制的是三角形，那么先配置一下帧缓冲，可以配置成2D纹理，然后进行原来的绘制，三角形就会绘制到缓冲帧的纹理上面，最后将这个2D纹理绘制到屏幕上就可以了。

实现方法：

原图形是很多个旋转的3D箱子

创建帧缓冲对象fbo，创建纹理对象tcbo和渲染缓冲对象rbo，将它们俩跟fbo绑定，检查一下是否成功。

创建顶点数组缓冲对象vbo，绘制一个带纹理的正方形，注意纹理需要用上一步创建的纹理对象tcbo

先绑定帧缓冲对象，开启深度测试，用原图形Shader绘制3D箱子图案；然后解绑帧缓冲对象fbo，关闭深度测试（绑定当前屏幕），用帧缓冲Shader绘制fbo中的纹理。绘制结果跟原图形完全一致。

有了帧缓冲后，可以在帧缓冲的片段着色器上做一些简单的图像处理：反相、灰度；核效果：模糊、锐化、边缘检测等。

6. Android （基础自定义组件）viewpagertap滑动器

视频地址： http://www.imooc.com/learn/615

2.1.1主要定义画笔、三角形使用path来实现。接着定义三角形的大小（宽高）以及初始化位置。
2.1.2设置mInitTranslationX参数，表示三角形初始化的位置，相当于marginLeft，计算方式是：
mInitTranslationX = 一个tab的宽度 - 三角形宽度的/2
2.1.3设置mTranslationX参数，表示每一移动一个tab时，三角形需要平移的宽度，如图：

2.1.4 mTabVisibleCount,自定义属性，布局中要显示几个tab,如上图4个tab

2.2.1构造中主要获取自定义属性值，默认为4；以及设置画笔

2.3.1三角形的宽度 = 一个tab宽度的1/6；如果觉得宽度的大小不合适， 可以改变1/6这个常量的比例

2.3.2三角形的高度 = 高度/2如图：

2.4.1重写父类dispatchDraw方法，此方法在invalidate（）时，会重新执行
2.4.2通过 canvas.translate（）设置三角形所在位置；X轴（上去看2.1.3），Y轴为但前组件的高度（最底部）。以及调用drawPath（）方法使用画笔。

2.5.1如标题主要是通过viewpager的position和positionOffset来计算mTranslationX的值；再通过scrollTo方法来平移但前组件，最后通过invalidate()方法重绘布局
2.5.2剩下的就是一些算法和逻辑判断

2.6.1获取viewpager,监听viewpager的滑动事件，自定义setScroll方法（2.5的方法）将但前position和滑动偏移量传进去
2.6.2在此次以及监听的viewpager的滑动事件，如果外界也需要监听当前viewpager的话，会起冲突；此时就需要设置回调，对外提供接口
2.6.3setTextHighLight()方法设置选中的tab为高亮颜色

2.7.1获取list集合，将每一个item设置成一个textview,再通过setTextItemOnclickEvent()方法设置点击事件

3.1app:visible_tab_count自定义属性；如果不设置默认为自定义组件的COUNT_TAB_VISIBLE变量值

http://pan..com/s/1qYGUTAW

http://pan..com/s/1slpi5v3

7. OpenGl ES 2.0 Learn For Android（五）碰撞检测

在现实生活里，碰撞是怎样发生的呢？是两个实体的边缘相接触。在OpenGL的视图世界里，肯定也是这个样子。但是我们不可能把一个物体的所有点都描述出来，然后在另一个集合里看是否有点的存在。
那么最简单的方式，就是将一个实体看做一个球，它的假设它的外边缘都在半径里。那么这个问题就简化成了，这个半径范围内，是否会有其他物体存在。
那我们在OpenGL世界坐标系里放置半径R1一个物体。如果是世界坐标系里放半径R2另一物体，那么，只要两个物体的中心位置距离dis小于两个物体半径和（R1+R2），就可以认为它们相交。这个是很容易理解的。
《OpenGL ES应用开发实践指南:Android卷》则用手指触点检测相交。其实这个问题并没有发生变化。我们还是在世界坐标系里看相交就好了。投射到屏幕的一个点，同样可以转换为世界坐标系里的两个点。这里涉及一些奇怪的技巧。比如，将一个不知道Z轴位置的点设置为-1/1。

这边我会做一个更简易的版本。我在世界坐标系里放置一个边长为1的正方体。如下图所示。

在之前讲到三角形的画法的时候，有讲到三角带。这是openGL为了节省节点，设计的绘制方案。这里的话，顶点也按对应的方式进行排布。
为了方便，我并没有绘制它的上下两个面。
将上一篇的顶点下面方式赋值。颜色也对应改改。

在上一篇的时候，我只用了modelMatrix和projectionMatrix。因为上一篇使用的默认视角，也就是从Z轴往它的负方向看去。
其实这一篇方向还是不会发生变化，但是这里需要用到视角的概念，也就是 setLookAtM() 这个方法。

所以引入这三个矩阵

viewMatrix 用来保存相机矩阵。 viewProjectionMatrix 用来保存透视投影和相机矩阵的乘积。 invertedViewProjectionMatrix 用来保存 viewProjectionMatrix 的逆矩阵。

因为要拿到触碰事件，给GlSurfaceView.setOnTouchListener

有意思的来了。我们知道，Android View的坐标系是左上角为原点，往右是x正方向，往下是y正方向。但是OpenGL ES归一化坐标里，坐标原点在屏幕正中央，往右是x正方向，往上是y正方向。 以X轴为例，要做是的从[0,1]映射到[-1,1]。那么x*2-1就可以达到想要的效果。这个如果后面有时间介绍构型函数，会见得很多。

我们拿到了触点的归一化坐标，我们要转换成世界坐标，这样才能做距离计算。
计算距离的工具类直接从示例中拿出来

这里光使用计算距离的方法，可以看书的9.2章。我觉得我肯定是没作者讲得好了。

使用上一篇用的投影参数，矩阵显得有些大了，所以在使用前，先把他们都缩小到1/5大小。

这里的话我要偷些懒，把 handleTouchPress 直接用上工具类里的方法。

在将点击的坐标转换为世界坐标里线段的方法里，有用到 invertedViewProjectionMatrix

它是 viewProjectionMatrix 的逆矩阵

那我做的判断是，如果点击了正方体，则停止旋转。效果如下

demo地址：
https://github.com/YueZhiFengMing/LearnOpenGl/tree/master/Fourth3D

8. android 中opengl画正方体，其顶底坐标还有索引是怎么计算和定义的

opengl es画图形都是通过三角形来画的，当然还可以画直线和点
画图形的时候有两种方法：glDrawArrays( ) 和glDrawElements( )

比如画一个由2个三角形组成的正方形，左上角坐标是l,t,右下角坐标是r,b
使用glDrawArrays绘制时，画2个三角形，需要这样传：
(l,t),(r,t),(l,b)
(r,t),(r,b),(l,b)
也就是说传的顶点数据就是按照顺时针或者逆时针排好顺序的，两个三角形的6个顶点

而用glDrawElements画的话可以这样
float coord[4][2]={{l,t},{r,t},{r,b},{l,b}};
绘制时用索引指定顶点顺序：
0,1,3
1,2,3

也就是说glDrawArrays传输或指定的数据是最终的真实数据,在绘制时效能更好
而glDrawElements指定的是真实数据的调用索引,在内存/显存占用上更节省

9. android中如何使用shape来显示直角三角形

用一个rectangle的shape，再用一个rotate标签包裹这个shape，设置rotate标签的fromDegree为30，pivotX为0%，pivotY为100%。

意思就是对矩形做一个旋转，让它变成直角三角形。

10. android skia与opengl es 都可以画2d图吗

一、基础知识: OpenGL ES目前只支持三角形，但任何多边形都可拆分成多个三角形，所以无所谓这个限制的存在。 1.OpenGL中的坐标点: 每一个坐标点由(X, Y, Z)组成。 定义一个三角形的顶点数组: [java] int one = 0x10000; //三角形三个顶点 private IntBuffer triggerBuffer = IntBuffer.wrap(new int[]{ 0,one,0, //上顶点 -one,-one,0, //左下点 one,-one,0,}); //右下点 int one = 0x10000; //三角形三个顶点 private IntBuffer triggerBuffer = IntBuffer.wrap(new int[]{ 0,one,0, //上顶点 -one,-one,0, //左下点 one,-one,0,}); //右下点定义一个正方形的顶点数组: [java] //正方形的4个顶点 private IntBuffer quaterBuffer = IntBuffer.wrap(new int[]{ one,one,0, -one,one,0, one,-one,0, -one,-one,0}); //正方形的4个顶点 private IntBuffer quaterBuffer = IntBuffer.wrap(new int[]{ one,one,0, -one,one,0, one,-one,0, -one,-one,0}); 2.OpenGL中的坐标系: 当调用gl.glLoadIdentity()函数之后，实际上是将当前点移动到了屏幕中心， X坐标轴从左至右，Y坐标轴从下至上，Z坐标轴从里至外。 OpenGL屏幕中心的坐标值是X轴和Y轴的0.0f点。 中心左边的坐标值是负值，右边是正值; 移向屏幕顶端是正值，移向屏幕底端是负值; 移入屏幕深处是负值，移出屏幕则是正值。 在绘制时，我们可以使用glTranslatef函数来移动画笔的位置，从而使图形显示在我们 想要的位置。 [java] gl.glTranslatef(-1.5f, 0.0f, -6.0f); gl.glTranslatef(-1.5f, 0.0f, -6.0f);此函数，就是将画笔沿X轴左移1.5f个单位，Y轴保持不变，Z轴向屏幕里面移动6.0f个单位。 将视图推入屏幕背后足够的距离以便可以看见全部的场景，这里需要注意的是屏幕内移动的单位 必须小于我们前面通过glFrustumf方法设置的最远距离，否则超出视角范围，将显示不出来。 3.OpenGL中的顶点数组: 在实际画图时，我们往往需要定位几个点，然后让OpenGL以此为基准来画图。在设置顶点位置前， 我们需要按照以下步骤来启用我们的顶点数组： ①开启顶点设置动能: [java] gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);②设置顶点数组: [java] view plainprint?gl.glVertexPointer(3, GL10.GL_FIXED, 0, triggerBuffer); gl.glVertexPointer(3, GL10.GL_FIXED, 0, triggerBuffer);glVertexPointer(int size, int type, int stride, Buffer pointer) size用于描述顶点的尺寸(本例使用XYZ，所以是3)，type描述顶点的类型，固定的使用 GL_FIXED，stride描述步长，pointer指向顶点缓存，即我们创建的顶点数组。 ③绘制顶点: [java] gl.glDrawArrays(GL10.GL_TRIANGLES, 0, 3); //绘制三角形 gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4); //绘制四边形 gl.glDrawArrays(GL10.GL_TRIANGLES, 0, 3); //绘制三角形 gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4); //绘制四边形glDrawArrays(int mode, int first, int count) mode指明绘制的模式，first和count分别是开始的位置和要绘制的顶点计数。 4、实例: 画一个三角形和正方形。 根据我们上一节的框架分析，目前，我们只需将精力集中在onDrawFrame方法里面的绘图操作部分了。 1. 界面编辑(reslayoutmain.xml)： [java] android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="@string/hello" /> 2.代码编辑 (srcwyfzclMyActivity.java)： [java] package wyf.zcl; import android.app.Activity; import android.opengl.GLSurfaceView; import android.opengl.GLSurfaceView.Renderer; import android.os.Bundle; public class Activity01 extends Activity { Renderer render = new GLRender(); /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); GLSurfaceView glView = new GLSurfaceView(this); glView.setRenderer(render); setContentView(glView); } } package wyf.zcl; import android.app.Activity; import android.opengl.GLSurfaceView; import android.opengl.GLSurfaceView.Renderer; import android.os.Bundle; public class Activity01 extends Activity { Renderer render = new GLRender(); /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); GLSurfaceView glView = new GLSurfaceView(this); glView.setRenderer(render); setContentView(glView); } } (srcwyfzclGLRender.java)： [java] package wyf.zcl; import java.nio.IntBuffer; import javax.microedition.khronos.egl.EGLConfig; import javax.microedition.khronos.opengles.GL10; import android.opengl.GLSurfaceView.Renderer; public class GLRender implements Renderer { int one = 0x10000; //三角形三个顶点 private IntBuffer triggerBuffer = IntBuffer.wrap(new int[]{ 0,one,0, //上顶点 -one,-one,0, //左下点 one,-one,0,}); //右下点 //正方形的4个顶点 private IntBuffer quaterBuffer = IntBuffer.wrap(new int[]{ one,one,0, -one,one,0, one,-one,0, -one,-one,0}); @Override public void onDrawFrame(GL10 gl) { // 清除屏幕和深度缓存 gl.glClear(GL10.GL_COLOR_BUFFER_BIT GL10.GL_DEPTH_BUFFER_BIT); // 重置当前的模型观察矩阵 gl.glLoadIdentity(); // 左移 1.5 单位，并移入屏幕 6.0 gl.glTranslatef(-1.5f, 0.0f, -6.0f); // 允许设置顶点 gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); // 设置三角形 gl.glVertexPointer(3, GL10.GL_FIXED, 0, triggerBuffer); //绘制三角形 gl.glDrawArrays(GL10.GL_TRIANGLES, 0, 3); // 重置当前的模型观察矩阵 gl.glLoadIdentity(); // 左移 1.5 单位，并移入屏幕 6.0 gl.glTranslatef(1.5f, 0.0f, -6.0f); //设置和绘制正方形 gl.glVertexPointer(3, GL10.GL_FIXED, 0, quaterBuffer); gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4); // 取消顶点设置 gl.glDisableClientState(GL10.GL_VERTEX_ARRAY); } @Override public void onSurfaceChanged(GL10 gl, int width, int height) { float ratio = (float) width / height; //设置OpenGL场景的大小 gl.glViewport(0, 0, width, height); //设置投影矩阵 gl.glMatrixMode(GL10.GL_PROJECTION); //重置投影矩阵 gl.glLoadIdentity(); // 设置视口的大小 gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10); // 选择模型观察矩阵 gl.glMatrixMode(GL10.GL_MODELVIEW); // 重置模型观察矩阵 gl.glLoadIdentity(); } @Override public void onSurfaceCreated(GL10 gl, EGLConfig config) { // 启用阴影平滑 gl.glShadeModel(GL10.GL_SMOOTH); // 黑色背景 gl.glClearColor(0, 0, 0, 0); // 设置深度缓存 gl.glClearDepthf(1.0f); // 启用深度测试 gl.glEnable(GL10.GL_DEPTH_TEST); // 所作深度测试的类型 gl.glDepthFunc(GL10.GL_LEQUAL); // 告诉系统对透视进行修正 gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST); } } package wyf.zcl; import java.nio.IntBuffer; import javax.microedition.khronos.egl.EGLConfig; import javax.microedition.khronos.opengles.GL10; import android.opengl.GLSurfaceView.Renderer; public class GLRender implements Renderer { int one = 0x10000; //三角形三个顶点 private IntBuffer triggerBuffer = IntBuffer.wrap(new int[]{ 0,one,0, //上顶点 -one,-one,0, //左下点 one,-one,0,}); //右下点 //正方形的4个顶点 private IntBuffer quaterBuffer = IntBuffer.wrap(new int[]{ one,one,0, -one,one,0, one,-one,0, -one,-one,0}); @Override public void onDrawFrame(GL10 gl) { // 清除屏幕和深度缓存 gl.glClear(GL10.GL_COLOR_BUFFER_BIT GL10.GL_DEPTH_BUFFER_BIT); // 重置当前的模型观察矩阵 gl.glLoadIdentity(); // 左移 1.5 单位，并移入屏幕 6.0 gl.glTranslatef(-1.5f, 0.0f, -6.0f); // 允许设置顶点 gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); // 设置三角形 gl.glVertexPointer(3, GL10.GL_FIXED, 0, triggerBuffer); //绘制三角形 gl.glDrawArrays(GL10.GL_TRIANGLES, 0, 3); // 重置当前的模型观察矩阵 gl.glLoadIdentity(); // 左移 1.5 单位，并移入屏幕 6.0 gl.glTranslatef(1.5f, 0.0f, -6.0f); //设置和绘制正方形 gl.glVertexPointer(3, GL10.GL_FIXED, 0, quaterBuffer); gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4); // 取消顶点设置 gl.glDisableClientState(GL10.GL_VERTEX_ARRAY); } @Override public void onSurfaceChanged(GL10 gl, int width, int height) { float ratio = (float) width / height; //设置OpenGL场景的大小 gl.glViewport(0, 0, width, height); //设置投影矩阵 gl.glMatrixMode(GL10.GL_PROJECTION); //重置投影矩阵 gl.glLoadIdentity(); // 设置视口的大小 gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10); // 选择模型观察矩阵 gl.glMatrixMode(GL10.GL_MODELVIEW); // 重置模型观察矩阵 gl.glLoadIdentity(); } @Override public void onSurfaceCreated(GL10 gl, EGLConfig config) { // 启用阴影平滑 gl.glShadeModel(GL10.GL_SMOOTH); // 黑色背景 gl.glClearColor(0, 0, 0, 0); // 设置深度缓存 gl.glClearDepthf(1.0f); // 启用深度测试 gl.glEnable(GL10.GL_DEPTH_TEST); // 所作深度测试的类型 gl.glDepthFunc(GL10.GL_LEQUAL); // 告诉系统对透视进行修正 gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST); } } 3.运行效果: