精华内容
下载资源
问答
  • 使用css等腰直角三角形

    千次阅读 2018-08-12 22:29:47
    使用css画个等腰直角三角形: 可以使用border来进行绘制,具体见注释 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"&...

    使用css画个等腰直角三角形:

    可以使用border来进行绘制,具体见注释

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
       
        <title>画直角三角形</title>
        <style>
            .triangle {
                width: 0px;
                height: 0px;
                border-width: 16px;
                border-style: solid; /*定义的是实现边框*/
                border-color: transparent #dadada #dadada transparent;
                /*顺时针顺序,上右底左*/
                /*若是三个值的话,上,左右两侧,底*/
                /*若是两个值的话,上底,左右两侧*/
                /*若是一个值的话,四个方向都一样*/
            }
        </style>
    </head>
    <body>
        <div class="triangle">
    
        </div>
    </body>
    </html>

     

    展开全文
  • OpenGL三角形 圆 五星 菱形

    千次阅读 2017-10-19 10:35:50
    用OPenGL原有的三角形,正方形,点的函数来作图。 画圆是用化曲为直的思想,把圆分为很多分,越分的多越细,越像圆。 菱形和圆的思想一样,来确定菱形顶点坐标。只是把圆周分的份数少一些 #include "stdafx.h" #...

    不开心,想玩,当家的不许我玩,还说你要玩就玩,那我不管你了,哭哭TAT


    用OPenGL原有的画三角形,正方形,点的函数来作图。

    画圆是用化曲为直的思想,把圆分为很多分,越分的多越细,越像圆。

    画菱形和圆的思想一样,来确定菱形顶点坐标。只是把圆周分的份数少一些


    #include "stdafx.h"
    #include<gl/glut.h>
    #include<math.h>
    #include <stdlib.h>
    const double PI = 3.14159265357f;
    const double R = 0.5f;
    const int n = 150;
    
    void myDisplay(void)
    {
    
    	glClearColor(1.0, 1.0, 1.0, 1.0);
    	glClear(GL_COLOR_BUFFER_BIT);
    	//画倒三角
    	glBegin(GL_TRIANGLES);
    	glColor3f(1.0f, 0.0f, 0.0f);  glVertex2f(0.0f, -1.0f);
    	glColor3f(0.0f, 1.0f, 0.0f);  glVertex2f(-1.0f, 1.0f);
    	glColor3f(1.0f, 1.0f, 0.0f);  glVertex2f(1.0f, 1.0f);
    	glEnd();
    	//画圆,思想:化曲为直
    	glBegin(GL_POLYGON);
    	for (int i = 1; i <= n; i++){
    		glVertex2f((R*cos(2 * PI / n*i)), R*sin(2 * PI / n*i));
    		glColor3f(1.0f, 0.0f, 1.0f);
    	}
    	glEnd();
    	//画五角星
    	GLfloat a = 1 / (2 - 2 * cos(72 * PI / 180));
    	GLfloat bx = a*cos(18 * PI / 180);
    	GLfloat by = a*sin(18 * PI / 180);
    	GLfloat cy = -a*cos(18 * PI / 180);
    	GLfloat pointB[2] = { bx, by },
    		pointC[2] = { 0.5, cy },
    		pointD[2] = { -0.5, cy },
    		pointE[2] = { -bx, by },
    		pointA[2] = { 0, a };
    
    	//按照A->C->E->B->D->A的顺序一笔画出五角星
    	glBegin(GL_LINE_LOOP);
    	glVertex2fv(pointA);
    	glVertex2fv(pointC);
    	glVertex2fv(pointE);
    	glVertex2fv(pointB);
    	glVertex2fv(pointD);
    	glVertex2fv(pointA);
    	glEnd();
    	//画两个小三角
    	glBegin(GL_TRIANGLES);
    	glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(-0.8f, -0.8f);
    	glColor3f(0.0f, 1.0f, 0.0f); glVertex2f(-0.7f, -0.8f);
    	glColor3f(0.0f, 0.0f, 1.0f); glVertex2f(-0.75f, -0.7f);
    	glEnd();
    
    	glBegin(GL_TRIANGLES);
    	glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(0.8f, -0.8f);
    	glColor3f(0.0f, 1.0f, 0.0f); glVertex2f(0.7f, -0.8f);
    	glColor3f(0.0f, 0.0f, 1.0f); glVertex2f(0.75f, -0.7f);
    	glEnd();
    	glFlush();
    
    }
    
    int main(int argc, char *argv[])
    {
    	glutInit(&argc, argv);
    	glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
    	glutInitWindowPosition(200, 200);
    	glutInitWindowSize(400, 400);
    	glutCreateWindow("Hellow World!");
    	glutDisplayFunc(&myDisplay);
    	glutMainLoop();
    	return 0;
    }
    

    下图为程序1 2 的运行结果



    
    #include "stdafx.h"
    #include<gl/glut.h>
    #include<math.h>
    #include <stdlib.h>
    void myDisplay(void)
    {
    	glClearColor(0.0, 0.0, 0.0, 0.0);
    	glClear(GL_COLOR_BUFFER_BIT);
    
    	//画白色正方形
    	glColor3f(1.0f, 1.0f, 1.0f);
    	glRectf(-0.5f, -0.5f, 0.5f, 0.5f);//这个函数只能画正的正方形
    
    	//画红色正方形
    	glBegin(GL_POLYGON);
    	glColor3f(1.0f, 0.0f, 0.0f); 
    	glVertex2f(0.0f, 0.5f);glVertex2f(0.5f, 0.0f);
    	glVertex2f(0.0f, -0.5f);
    	
    	glVertex2f(-0.5f, 0.0f);
    	glEnd();
    
    	//画三角形
    	glBegin(GL_TRIANGLES);
    	glColor3f(0.2f, 0.4f, 0.8f);  glVertex2f(0.5f, 0.5f);
    	glColor3f(0.2f, 0.4f, 0.8f);  glVertex2f(-0.5f, 0.5f);
    	glColor3f(0.2f, 0.4f, 0.8f);  glVertex2f(0.0f, 1.0f);
    	glEnd();
    
    	glBegin(GL_TRIANGLES);
    	glColor3f(0.9f, 0.9f, 0.0f);  glVertex2f(0.5f, 0.5f);
    	glColor3f(0.9f, 0.9f, 0.0f);  glVertex2f(0.5f, -0.5f);
    	glColor3f(0.9f, 0.9f, 0.0f);  glVertex2f(1.0f, 0.0f);
    	glEnd();
    
    	glBegin(GL_TRIANGLES);
    	glColor3f(0.0f, 1.0f, 0.0f);  glVertex2f(0.5f, -0.5f);
    	glColor3f(0.0f, 1.0f, 0.0f);  glVertex2f(-0.5f, -0.5f);
    	glColor3f(0.0f, 1.0f, 0.0f);  glVertex2f(0.0f, -1.0f);
    	glEnd();
    
    	glBegin(GL_TRIANGLES);
    	glColor3f(0.9f, 0.5f, 0.9f);  glVertex2f(-0.5f, 0.5f);
    	glColor3f(0.9f, 0.5f, 0.9f);  glVertex2f(-0.5f, -0.5f);
    	glColor3f(0.9f, 0.5f, 0.9f);  glVertex2f(-1.0f, 0.0f);
    	glEnd();
    
    	glFlush();
    
    }
    
    int main(int argc, char *argv[])
    {
    	glutInit(&argc, argv);
    	glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
    	glutInitWindowPosition(200, 200);
    	glutInitWindowSize(400, 400);
    	glutCreateWindow("Hellow World!");
    	glutDisplayFunc(&myDisplay);
    	glutMainLoop();
    	return 0;
    }



    
    #include "stdafx.h"
    #include<gl/glut.h>
    #include<math.h>
    #include <stdlib.h>
    const double PI = 3.14159265357f;
    
    
    void myDisplay(void)
    {
    	glClearColor(0.0, 0.0, 0.0, 0.0);
    	glClear(GL_COLOR_BUFFER_BIT);
    	//红色菱形
    	glBegin(GL_POLYGON);
    	glColor3f(1.0f, 0.0f, 0.0f);
    	glVertex2f(0.0f, 0.0f);
    	glVertex2f(0.5f, 0.5 *(tan(22.5*PI/180)));
    	glVertex2f(1.0f, 0.0f);
    	glVertex2f(0.5f, -0.5 *(tan(22.5*PI/180)));
    	glEnd();
    
    	glBegin(GL_POLYGON);
    	glColor3f(1.0f, 0.0f, 0.0f);
    	glVertex2f(0.0f, 0.0f);
    	glVertex2f(-0.5f, 0.5 *(tan(22.5*PI / 180)));
    	glVertex2f(-1.0f, 0.0f);
    	glVertex2f(-0.5f, -0.5 *(tan(22.5*PI / 180)));
    	glEnd();
    
    	glBegin(GL_POLYGON);
    	glColor3f(1.0f, 0.0f, 0.0f);
    	glVertex2f(0.0f, 0.0f);
    	glVertex2f(0.5*(tan(22.5*PI / 180)),0.5f);
    	glVertex2f(0.0f, 1.0f);
    	glVertex2f(-0.5*(tan(22.5*PI / 180)),0.5f);
    	glEnd();
    
    	glBegin(GL_POLYGON);
    	glColor3f(1.0f, 0.0f, 0.0f);
    	glVertex2f(0.0f, 0.0f);
    	glVertex2f(0.5*(tan(22.5*PI / 180)), -0.5f);
    	glVertex2f(0.0f, -1.0f);
    	glVertex2f(-0.5*(tan(22.5*PI / 180)), -0.5f);
    	glEnd(); 
    
    	//绿色菱形
    	glBegin(GL_POLYGON);
    	glColor3f(0.0f, 1.0f, 0.0f);
    	glVertex2f(0.0f, 0.0f);
    	glVertex2f(0.5f, 0.5 *(tan(22.5*PI / 180)));
    	glVertex2f(cos(45 * PI / 180), cos(45 * PI / 180));
    	glVertex2f(0.5*(tan(22.5*PI / 180)), 0.5f);
    	glEnd();
    
    	glBegin(GL_POLYGON);
    	glColor3f(0.0f, 1.0f, 0.0f);
    	glVertex2f(0.0f, 0.0f);
    	glVertex2f(0.5f, -0.5 *(tan(22.5*PI / 180)));
    	glVertex2f(cos(45 * PI / 180), -cos(45 * PI / 180));
    	glVertex2f(0.5*(tan(22.5*PI / 180)), -0.5f);
    	glEnd();
    
    	glBegin(GL_POLYGON);
    	glColor3f(0.0f, 1.0f, 0.0f);
    	glVertex2f(0.0f, 0.0f);
    	glVertex2f(-0.5f, 0.5 *(tan(22.5*PI / 180)));
    	glVertex2f(-cos(45 * PI / 180), cos(45 * PI / 180));
    	glVertex2f(-0.5*(tan(22.5*PI / 180)), 0.5f);
    	glEnd();
    
    	glBegin(GL_POLYGON);
    	glColor3f(0.0f, 1.0f, 0.0f);
    	glVertex2f(0.0f, 0.0f);
    	glVertex2f(-0.5f, -0.5 *(tan(22.5*PI / 180)));
    	glVertex2f(-cos(45 * PI / 180), -cos(45 * PI / 180));
    	glVertex2f(-0.5*(tan(22.5*PI / 180)), -0.5f);
    	glEnd();
    
    	glFlush();
    
    }
    
    int main(int argc, char *argv[])
    {
    	glutInit(&argc, argv);
    	glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
    	glutInitWindowPosition(200, 200);
    	glutInitWindowSize(400, 400);
    	glutCreateWindow("Hellow World!");
    	glutDisplayFunc(&myDisplay);
    	glutMainLoop();
    	return 0;
    }

    运行结果:


    展开全文
  • opengl es-点 线 三角形

    千次阅读 2011-07-19 15:04:03
    在android上点,线,三角形等可以使用以下两函数 glDrawArrays(); 这速度快,但是很多东西/复杂形状时消耗资源... 这是读取索引值来,消耗资源。 线,三角形等形状时需要注意保存的点的顺序。 另外
    在android上画点,线,三角形等可以使用以下两个函数
      glDrawArrays(); 这个速度快,但是很多东西/复杂形状时消耗资源也大。
      glDrawElements(); 这个是读取索引值来画,消耗资源小。
      
      画线,三角形等形状时需要注意保存的点的顺序。
      另外,就是需要注意参数的意义。
      比如:
      GL_TRIANGLE_FAN 和 GL_TRIANGLE_STRIP 就决定了不同得顶点组织方式。
      
      GL_TRIANGLE_STRIP - OpenGL的使用将最开始的两个顶点出发,然后遍历每个顶点,这些顶点将和他的前2个顶点一起组成一个三角形。 GL_TRIANGLE_FAN - 在跳过开始的2个顶点,然后遍历每个顶点,让OpenGL将这些顶点和它前一个,以及数组的第一个顶点一起组成一个三角形。

    GL_TRIANGLES、GL_TRIANGLE_STRIP、GL_TRIANGLE_FAN。下面分别介绍:

    GL_POINTS:把每一个顶点作为一个点进行处理,顶点n即定义了点n,共绘制n个点。·

    GL_LINES:把每一个顶点作为一个独立的线段,顶点2n-1和2n之间共定义了n个线段,总共绘制N/2条线段。,如果N为奇数,则忽略最后一个顶点。·

    GL_LINE_STRIP:绘制从第一个顶点到最后一个顶点依次相连的一组线段,第n和n+1个顶点定义了线段n,总共绘制N-1条线段。

    GL_LINE_LOOP:绘制从定义第一个顶点到最后一个顶点依次相连的一组线段,然后最后一个顶点与第一个顶点相连。第n和n+1个顶点定义了线段n,然后最后一个线段是由顶点N和1之间定义,总共绘制N条线段。·

    GL_TRIANGLES:把每三个顶点作为一个独立的三·角形。顶点3n-2,3n-1和3n定义了第n个三角形,总共绘制N/3个三角形。

    GL_TRIANGLE_STRIP:绘制一组相连的三角形。对于奇数点n,顶点n,n+1和n+2定义了第n个三角形;对于偶数n,顶点n+1,n和n+2定义了第n个三角形,总共绘制N-2个三角形。·

    · GL_TRIANGLE_FAN:绘制一组相连的三角形。三角形是由第一个顶点及其后给定的顶点所确定。顶点1,n+1和n+2定义了第n个三角形,总共绘制N-2个三角形。
    展开全文
  • 为了方便没有准备好梯子的同学,我把项目在CSDN上打包下载,不过更新会慢一些回到目录初始化OpenGL ES环境OpenGL ES的使用,一般包括如下几步骤: 1. EGL Context初始化 2. OpenGL ES初始化 3. OpenGL ES...

    Github项目地址,欢迎star~!

    为了方便没有准备好梯子的同学,我把项目在CSDN上打包下载,不过更新会慢一些

    回到目录

    初始化OpenGL ES环境

    OpenGL ES的使用,一般包括如下几个步骤:
    1. EGL Context初始化
    2. OpenGL ES初始化
    3. OpenGL ES设置选项与绘制
    4. OpenGL ES资源释放(可选)
    5. EGL资源释放

    Android平台提供了一个GLSurfaceView,来帮助使用者完成第一步和第五步,由于释放EGL资源时会自动释放之前申请的OpenGL ES资源,所以需要我们自己做的就只有2和3。

    使用GLSurfaceView

    首先,我们在主布局中引入一个GLSurfaceView,并让他充满整个布局,并在Activity中获取他的实例

    <android.opengl.GLSurfaceView
            android:id="@+id/surface_view"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />
    public class MainActivity extends AppCompatActivity {
    
        private GLSurfaceView glSurfaceView;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            glSurfaceView= (GLSurfaceView) findViewById(R.id.surface_view);
        }
    }
    

    获取实例以后,我们就可以对于这个GLSurfaceView进行配置:

    glSurfaceView.setEGLContextClientVersion(2);
    glSurfaceView.setRenderer(new GLRenderer());
    glSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);

    第一行是设置EGL上下文的客户端版本,因为我们使用的是OpenGL ES 2.0,所以设置为2
    第二行代表渲染模式,选项有两种(大家应该能看懂英文的介绍),一个是需要渲染(触控事件,渲染请求)才渲染,一个是不断渲染。

     /**
         * The renderer only renders
         * when the surface is created, or when {@link #requestRender} is called.
         *
         * @see #getRenderMode()
         * @see #setRenderMode(int)
         * @see #requestRender()
         */
        public final static int RENDERMODE_WHEN_DIRTY = 0;
        /**
         * The renderer is called
         * continuously to re-render the scene.
         *
         * @see #getRenderMode()
         * @see #setRenderMode(int)
         */
        public final static int RENDERMODE_CONTINUOUSLY = 1;

    这个GLRenderer是个什么鬼?其实这是我们自定义的一个类,实现了GLSurfaceView.Renderer这个接口,用来完成绘制操作。现在我们来看看这个类的定义:

    public class GLRenderer implements GLSurfaceView.Renderer {
    
        @Override
        public void onSurfaceCreated(GL10 gl, EGLConfig config) {
    
        }
    
        @Override
        public void onSurfaceChanged(GL10 gl, int width, int height) {
    
        }
    
        @Override
        public void onDrawFrame(GL10 gl) {
    
        }
    }

    可以看到,我们只是简单的实现了GLSurfaceView.Renderer这个接口,还没有写任何操作,现在让我们来看看程序运行的效果:
    这里写图片描述

    一片漆黑(白色边是因为布局的Padding)。。现在我们来分别看一下这三个函数

    • public void onSurfaceCreated(GL10 gl, EGLConfig config)
      从名字可以看出,这个函数在Surface被创建的时候调用,每次我们将应用切换到其他地方,再切换回来的时候都有可能被调用,在这个函数中,我们需要完成一些OpenGL ES相关变量的初始化

    • public void onSurfaceChanged(GL10 gl, int width, int height)
      每当屏幕尺寸发生变化时,这个函数会被调用(包括刚打开时以及横屏、竖屏切换),width和height就是绘制区域的宽和高(上图黑色区域)

    • public void onDrawFrame(GL10 gl)
      这个是主要的函数,我们的绘制部分就在这里,每一次绘制时这个函数都会被调用,之前设置了GLSurfaceView.RENDERMODE_CONTINUOUSLY,也就是说按照正常的速度,每秒这个函数会被调用60次,虽然我们还什么都没做

    为了进行下一步工作,在我们创建这个类时,传入一个上下文并保存起来

    private Context context;
    
    public GLRenderer(Context context) {
        this.context = context;
    }
    glSurfaceView.setRenderer(new GLRenderer(this));

    好了,现在我们开始绘制操作,先创建一个工具类ShaderUtils,因为这里介绍的功能我们会多次用到。

    其中的一个函数用来读取raw中的文本文件,并且以String的形式返回,这个其实和OpenGL ES的关系并不大,代码如下:

    public static String readRawTextFile(Context context, int resId) {
        InputStream inputStream = context.getResources().openRawResource(resId);
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line).append("\n");
            }
            reader.close();
            return sb.toString();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    我们再在raw文件夹中创建两个文件,fragment_shader.glsl和vertex_shader.glsl,他们分别是片元着色器和顶点着色器的脚本,之前说的可编程管线,就是指OpenGL ES 2.0可以即时编译这些脚本,来实现丰富的功能,两个文件的内容如下:

    vertex_shader.glsl

    attribute vec4 aPosition;
    void main() {
      gl_Position = aPosition;
    }

    vec4是一个包含4个浮点数(float,我们约定,在OpenGL中提到的浮点数都是指float类型)的向量,attribute表示变元,用来在Java程序和OpenGL间传递经常变化的数据,gl_Position 是OpenGL ES的内建变量,表示顶点坐标(xyzw,w是用来进行投影变换的归一化变量),我们会通过aPosition把要绘制的顶点坐标传递给gl_Position

    fragment_shader.glsl

    precision mediump float;
    void main() {
        gl_FragColor = vec4(0,0.5,0.5,1);
    }

    precision mediump float用来指定运算的精度以提高效率(因为运算量还是蛮大的),gl_FragColor 也是一个内建的变量,表示颜色,以rgba的方式排布,范围是[0,1]的浮点数

    先完成onSurfaceCreated的代码

    使用readRawTextFile把文件读进来,然后创建一个OpenGL ES程序

    String vertexShader = ShaderUtils.readRawTextFile(context, R.raw.vertex_shader);
    String fragmentShader= ShaderUtils.readRawTextFile(context, R.raw.fragment_shader);
    programId=ShaderUtils.createProgram(vertexShader,fragmentShader);

    读取文件应该好理解,创建程序就比较复杂了,具体的步骤是这样的,我们先看创建程序之前要做的事情:
    1. 创建一个新的着色器对象
    2. 上传和编译着色器代码,就是我们之前读进来的String
    3. 读取编译状态(可选)

    public static int loadShader(int shaderType, String source) {
        int shader = GLES20.glCreateShader(shaderType);
        if (shader != 0) {
            GLES20.glShaderSource(shader, source);
            GLES20.glCompileShader(shader);
            int[] compiled = new int[1];
            GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
            if (compiled[0] == 0) {
                Log.e(TAG, "Could not compile shader " + shaderType + ":");
                Log.e(TAG, GLES20.glGetShaderInfoLog(shader));
                GLES20.glDeleteShader(shader);
                shader = 0;
            }
        }
        return shader;
    }

    shaderType用来指定着色器类型,取值有GLES20.GL_VERTEX_SHADER和GLES20.GL_FRAGMENT_SHADER,source就是刚才读入的代码,如果创建成功,那么shader会是一个非零的值,我们用GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);来获取编译的状态,如果创建失败,就删除这个着色器:GLES20.glDeleteShader(shader);

    
    public static int createProgram(String vertexSource, String fragmentSource) {
        int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
        if (vertexShader == 0) {
            return 0;
        }
        int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
        if (pixelShader == 0) {
            return 0;
        }
    
        int program = GLES20.glCreateProgram();
        if (program != 0) {
            GLES20.glAttachShader(program, vertexShader);
            checkGlError("glAttachShader");
            GLES20.glAttachShader(program, pixelShader);
            checkGlError("glAttachShader");
            GLES20.glLinkProgram(program);
            int[] linkStatus = new int[1];
            GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
            if (linkStatus[0] != GLES20.GL_TRUE) {
                Log.e(TAG, "Could not link program: ");
                Log.e(TAG, GLES20.glGetProgramInfoLog(program));
                GLES20.glDeleteProgram(program);
                program = 0;
            }
        }
        return program;
    }

    我们先创建顶点着色器和片元着色器,然后用GLES20.glCreateProgram()创建程序,同样地,如果创建成功,会返回一个非零的值,我们用GLES20.glAttachShader(program, shaderID)这个函数把程序和着色器绑定起来,然后用GLES20.glLinkProgram(program)链接程序(编译链接,好有道理的样子。。)GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);和之前的类似,是用来获取链接状态的。

    另外还有一个打印错误日志的功能函数:

    public static void checkGlError(String label) {
        int error;
        while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
            Log.e(TAG, label + ": glError " + error);
            throw new RuntimeException(label + ": glError " + error);
        }
    }

    创建好了程序之后,我们获取之前顶点着色器中,aPosition的引用,以便于传送顶点数据

    aPositionHandle= GLES20.glGetAttribLocation(programId,"aPosition");

    完成向OpenGL的数据传送

    OpenGL ES工作在native层(C、C++),如果要传送数据,我们需要使用特殊的方法把数据复制过去。首先定义一个顶点数组,这是我们要绘制的三角形的三个顶点坐标(逆时针),三个浮点数分别代表xyz,因为是在平面上绘制,我们把z设置为0

    private final float[] vertexData = {
            0f,0f,0f,
            1f,-1f,0f,
            1f,1f,0f
    };

    如果程序正常工作,那么我们的三角形应该出现在这个区域(见下图):
    这里写图片描述

    我们使用一个FloatBuffer将数据传递到本地内存,目前这个类中的全局变量如下:

    private Context context;
    private int aPositionHandle;
    private int programId;
    private FloatBuffer vertexBuffer;

    我们在类的构造函数中把顶点数据传递过去:

    vertexBuffer = ByteBuffer.allocateDirect(vertexData.length * 4)
            .order(ByteOrder.nativeOrder())
            .asFloatBuffer()
            .put(vertexData);
    vertexBuffer.position(0);

    一个float是4个字节,ByteBuffer用来在本地内存分配足够的大小,并设置存储顺序为nativeOrder(关于存储序的更多资料可以在维基百科上找到),最后把vertexData放进去,当然,不要忘了设定索引位置vertexBuffer.position(0);

    完成onDrawFrame

    完成了上述工作以后,我们就可以来画三角形了(好辛苦。。)

    @Override
    public void onDrawFrame(GL10 gl) {
        GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
        GLES20.glUseProgram(programId);
        GLES20.glEnableVertexAttribArray(aPositionHandle);
        GLES20.glVertexAttribPointer(aPositionHandle, 3, GLES20.GL_FLOAT, false,
                12, vertexBuffer);
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);
    }

    第一行用来清空颜色缓冲区和深度缓冲区,然后我们指定使用刚才创建的那个程序。GLES20.glEnableVertexAttribArray(aPositionHandle);的作用是启用顶点数组,aPositionHandle就是我们传送数据的目标位置。
    GLES20.glVertexAttribPointer的原型是这样的:

    glVertexAttribPointer(
            int indx,
            int size,
            int type,
            boolean normalized,
            int stride,
            java.nio.Buffer ptr
    )

    stride表示步长,因为一个顶点三个坐标,一个坐标是float(4字节),所以步长是12字节
    (当然,这个只在一个数组中同时包含多个属性时才有作用,例如同时包含纹理坐标和顶点坐标,在只有一种属性时(例如现在),和传递0是相同效果)

    最后,我们用GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);把三角形画出来,glDrawArrays的原型如下,我就不解释了

    public static native void glDrawArrays(
        int mode,
        int first,
        int count
    );

    编译运行,效果应该是这样的:
    这里写图片描述
    咦,画出来的不是等腰三角形嘛,就像我们之前说的,OpenGL会把整个屏幕(其实是整个可以绘制的区域,也就是前面黑色的区域)当成输出,所以我们画出来的三角形出现了变形。那么横屏的情况下是什么样的呢? 来看一下:

    这里写图片描述

    在下一节,我们会学习如何来处理这种情况,并且学习如何用OpenGL绘制一张图片。

    PS:三角形是OpenGL的基本形状,很多复杂的几何体,都是通过切分成三角形来绘制的,后面我们会越来越深刻的感受到这一点。

    展开全文
  • 上篇文章讲了opengl es的基本知识,GLSurfaceView的创建,点等内容,这篇文章将opengl es另外的一些基本操作,比如线,三角形,正方形等,以及这些例子中涉及了相关的知识点。  1、线,线的操作和点...
  • 3个参数分别为:需要的数据的类型,哪一点开始,需要的点的个数 } } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar ...
  • 在openGL中,所有面状图形的绘制都是使用三角形方法,而针对不同需求,openGL给出三种不同的三角形方法: ①traingles:三角形集 ②traingle_strip:三角形带 ③traingle_fan:三角形扇面 ...
  • 使用starUML一步一步画顺序

    千次阅读 2018-06-13 20:35:05
    顺序图:是UML中能表现过程中各个详细步骤的模型图,过程可以理解为一功能的执行过程。下面我们以一简单的影院管理系统中售票功能为例来一步一步完成顺序图的构建。建模工具:starUML 版本:5.0.2.1570...
  • 经过这半天,总算自己写了一可以画出三角形和正方形的代码,顺便对网上一堆的代码封装了下。嗯,开始说吧。 首先感谢这篇教程: http://hukai.me/android-training-course-in-chinese/graphics/opengl/en
  • GPU像素的顺序是什么

    千次阅读 2016-09-21 09:35:05
    熟悉实时图形的人都知道,GPU里面有很一块是rasterizer,用来把VS输出的顶点数据光栅化成像素数据,交给PS。然而,这部分一直是一黑盒。GPU是以什么样的顺序进行光栅化?传统光栅化和tile-bas
  • 用VC星的方法

    千次阅读 2013-06-18 19:19:31
    星有五个点,通过其中的两个可以确定圆心,由圆心可以找另外的三个点,只要把这五个点都找全了,运用pDC->MoveTo() ,pDC->LineTo()按一定的点顺序就可以把五出来。   //这是在确定五个点的坐标。 ...
  • 用OpenGL

    千次阅读 2018-03-23 17:53:39
    学期学的图形学,主要是讲OpenGL的东西,老师让我们自己用GL_LINES、GL_LINE_LOOP、GL_LINE_STRIP等方式一些自己觉得好看的图形(由于不是教程文章,就不解释这些方法的意思和其他基本的东西了),于是理科生...
  • 在unity的scene中

    千次阅读 2015-08-13 10:45:45
    首先在场景中找到五星的五定点的坐标,按照一笔画的顺序命名为1,2,3,4,5,如图所示: 接下来就是编写代码了,代码很少,如下所示: using UnityEngine; using System.Collections; public class fiveStars : ...
  • 3维这术语表示一正在描述或显示的物体具有维维度:宽度、高度、深度;--计算机3D图形实质上也是平面的;--在计算机屏幕上显示的二维图像,提供深度(或第维)的错觉;2D+透视 = 3D透视使人产生深度的...
  • Direct3D 11教程2:绘制一三角形

    千次阅读 2014-04-23 15:23:02
    概览 在前面的教程中,我们创建了一个最小化的Direct3D 11程序在平面上输出了单一的颜色。 本教程中,我们会在屏幕上绘制一个三角形。我们会学习设置三角形数据结构的方法。...确定位置的三个顶点定
  • 使用CSS萌萌的

    千次阅读 2016-09-27 16:38:47
    实验楼的一项目,萌萌的白,完全使用css来,用css3的圆角和阴影就可以达到效果,一起开始吧! 首先要写一html文件,定义这个大白的各个结构,然后用css将这些结构渲染表现出来。 hml文件:<!DOCTYPE...
  • 如何用 Python 画出 69 岁老同志?

    万次阅读 多人点赞 2020-11-25 21:01:25
    【P实战】教你最有趣的 Python 入门项目每周,痴海会教你一 Python 实战项目。编程能力想要快速的提升,唯有不断的实战。而对于许多零基础的同学,很难找到适合的入门级项目。所以...
  • 程序入门快速开发程序项目

    万次阅读 多人点赞 2018-08-19 21:39:39
    作者:谭东 备注:程序只是突发灵感兴趣弄的,...然后有目标的进行实践,也就是要实现你想要的程序,这样边实践边学习才能够有疑问,才能够更快的理解和学习程序开发。所以后续几天就开始程序实践和学习...
  • svg星,关于fill-rule的理解

    千次阅读 2016-12-06 10:46:20
    nonzero—这规则通过canvas上的某个点往任一方向绘制射线无穷远,然后检查图形的线段和射线相交的点,来确定“内部区域”。0开始计数,每次路径线段是右穿过射线就加一,左的就减一。通过计算...
  • 小子第一次写博客,格式不太会,大家见谅。 在Google翻译的帮助下,用了自己的所有的英文知识取了一控件名字RoundLabelTextView。
  • 上面的三个```也就是esc健对应下面的健。 在空白处输入下面的源码即可,按照mermaid语法格式来操作即可。 一、流程图 1)、竖向(TD 表示下) graph TD; A-->B; A-->C; B-->D; D-->E; D-->F; 2)、横向(LR ...
  • 本笔记是基于Microsfot DirectX 9.0...而三角形由三个顶点构成;每个顶点不仅包括其坐标信息,还包括顶点的颜色、法向量和贴图坐标等信息。 第一步:准备顶点信息 1. 要先定义个顶点信息结构。 struct CUSTOMVERTEX{ 
  • 顺序

    万次阅读 多人点赞 2016-12-31 18:06:39
    一:定义 1,UML顺序图一般用于确认和丰富一使用情境的逻辑。 2,一使用情境的逻辑或是一...3顺序图将交互关系表现为一二维图,纵向是时间轴,时间沿竖线向下延伸。横向轴代表了在协作中各独立对象的类元角色
  • Unity3D中脚本的执行顺序和编译顺序

    千次阅读 2016-10-30 21:45:44
    Unity3D中脚本的执行顺序和编译顺序 在Unity中可以同时创建很多脚本,并且可以分别绑定不同的游戏对象上,它们各自都在自己的生命周期中运行。与脚本有关的也就是编译和执行...我们可以做一个小实验来测试一下:
  • 横向流程图 a=1a=2方形圆角条件a结果1结果2横向流程图 竖向流程图 a=1a=2方形圆角条件a结果1结果2竖向流程图 标准流程图 Created with Raphaël 2.2.0开始框处理框判断框(是或否?)输入输出框结束框子流程yesno ...
  • WebGL彩色矩形

    千次阅读 2017-06-26 17:21:17
    今天和大家分享一用WebGL矩形(rectangle)的Demo,也可用来绘制三角形(triangle)。本文适用于初学者掌握WebGL的基本绘图知识,WebGL是OpenGL的Web版本,所以它的绘图过程与OpenGL是一样的,这里不赘述,大家...
  • Rational类图中的几个小技巧

    千次阅读 2010-04-24 18:51:00
    Rational这东西使人又爱又恨,爱是因为它功能确实... 如果在类图中直接使用DEL键删除,则默认是"图中删除",此时类图中没有了,但类还是存在模型中的,可以再拖类图中;但"模型中删除"就是直接把类删掉了,只
  • 在做平面机械臂(三轴台、SCARA)的手眼标定时,尝试使用棋盘格标定板来实现九点标定,要求每次求的Corners都按相同的排列顺序,但是bool cv::findChessboardCorners函数求的Corners排列顺序并不确定,只能对...
  • 代码的执行顺序如下,第一步先执行行的循环,第二步执行左侧填充的直角三角形的循环,第步执行正三角形的循环 这段代码中利用不同的符号及sleep函数可以控制显示及执行速度,以便初学者看清代码运行逻辑 ...
  • 知识点:CSS3 transform 属性、transition属性 实现效果: 效果说明:一排图片大小一致,当鼠标放在任一图片上时,图片放大并且旋转。 制作思路: 1、给图片添加&lt;a&gt;标签,利用伪类选择器实现 2、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,272
精华内容 23,308
关键字:

从大到小的顺序画出3个角