精华内容
下载资源
问答
  • OPENGL 开发文档

    2011-07-06 18:32:23
    opengl是3D的基础,其中的理念和逻辑是很多3d场合使用的,本文档用图文并茂的形式,跟你真是展示了一个OPENGL开发接口,相信你看了之后有大的收获,对OPENGL有一定的了解。
  • 最全的AndroidOpenGL开发文档
  • openGL 开发文档,含代码,对初学有帮助。
  • OpenGL文档开发

    2009-09-14 14:25:03
    利用opengl实现的一些比较悬的效果,可用于初学者学习
  • OpenGL开发系列文档.rar

    2012-10-21 08:58:02
    包含《OpenGL超级宝典》、《OpenGL开发指南》、《OpenGL中文版》,是学习和查阅的最佳工具。
  • 全部摘自优秀的博客,这里面会教你快速一步步搭建出opengl开发平台,都是值得珍藏的优秀博客,但是自己搜索可能找不到需要的。同时也可以下载我上传的另一个资料,是opengl在vs2015上的所有开发包,省去自己从官网上...
  • OPENGL文档.rar

    2011-05-05 16:14:48
    OPENGL文档 框架设计以及头文件加载等问题
  • opengl 帮助文档

    2019-05-30 01:44:15
    NULL 博文链接:https://wangzhigang2.iteye.com/blog/1048344
  • android opengl学习文档

    2013-05-21 09:49:41
    以上介绍了Android OpenGL ES相关的Buffer的使用方法,将在不久的将来详细介绍OpenGL ES开发指南。
  • Opengl文档控制显示

    2012-12-29 03:21:47
    基于vc++和opengl开发的界面程序,可提供参考
  • OpenGL开发教材

    2012-02-16 10:28:53
    文档是OPenGl 入门开发教程 对于刚入门想了解OPENGL开发的爱好者有很大的帮助
  • 总结opengles在android平台开发的各种应用、重点、难点。它将带你慢慢的由无知到精通全程。
  • OpenGL 开发环境搭建

    2019-07-16 23:34:29
    OpenGL 开发环境搭建Mac OpenGL开发环境搭建1. 准备资源2. 手动配置环境3. 使用命令配置环境Mac OSX下搭建OpenGL超级宝典5(蓝宝书)开发环境window OpenGL开发环境搭建 Mac OpenGL开发环境搭建 1. 准备资源 ...

    Mac OpenGL开发环境搭建

    1. 准备资源

    • CLTools
    • glew
    • libGLTools.a

    资源下载地址:https://pan.baidu.com/s/1RSd5xo42Rlh0o8ZkPsyDcg

    2. 手动配置环境

    1. 打开XCode -> macOS -> Cocoa Application
      在这里插入图片描述
    2. 添加OpenGL.framework和GLUT.framework两个框架
      在这里插入图片描述
    3. 将 include 文件和 libGLTools.a 导入项目中,libGLTools.a文件放入 Framework 中
      在这里插入图片描述
    4. 删除项目中的 AppDelegate.h, AppDelegate.m, ViewController.h, ViewController.m, main.m 文件
      在这里插入图片描述
    5. 创建 main.cpp 文件
      在这里插入图片描述
    6. 开始编写OpenGL代码,运行

    3. 使用命令配置环境

    https://learnopengl-cn.github.io

    1. 安装brew ,如果已经安装,直接跳过该步骤
      在终端输入:(我是之前安装过brew 这里只是大概的说明安装流程,没有安过的可以百度一下很多的)
    $ gcc --version
    ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
    $ brew doctor
    $brew update
    
    1. 安装GLEW和GLFW库
    $ brew install glew
    $ brew install glfw3
    
    1. 下载GLAD库
      ① 打开GLAD的在线服务:http://glad.dav1d.de 如图设置 OpenGL使用的是3.3 版本 至于为什么使用3.3 请看 https://learnopengl-cn.github.io 这里。

    在这里插入图片描述

    在这里插入图片描述
    包含两个头文件目录,和一个glad.c文件。将两个头文件目录(glad和KHR)复制到Include文件夹中(路径"/usr/local/include")(可以使用cmd + shift + g )。

    1. 新建一个工程
      在这里插入图片描述
    2. 删除相关文件如图所示
      在这里插入图片描述
    3. 设置

    build setting 找到 header search paths
    ->添加“/usr/local/include”路径到Header Search Paths
    ->添加“$(inherited)”
    “/usr/local/Cellar/glfw/3.2.1/lib”
    “/usr/local/Cellar/glew/2.2.0/lib”路径到Header Search Paths

    在这里插入图片描述

    1. Build Phases 找到 Link Binary With Libraries 增加如下内容
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
    2. 将我们下载的glad.zip 解压的glad.c 文件拖进项目
      在这里插入图片描述
    3. 新建一个c++ main.cpp 程序 如图
      在这里插入图片描述
    4. 编写一个简单的openGL代码:
    #include <stdio.h>
    #include <iostream>
    #include <glad/glad.h>
    #include <GLFW/glfw3.h>
    
    
    int main(int argc, char **argv){
        using std::cout;    using std::endl;
        glfwInit();
    //    主版本
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    //    次版本
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    //    告诉glfw 我们使用的是core_profile 核心模块
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    //    向前兼容
        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    //    创建一个GLFW 窗口   宽 高  窗口名字  后边两个暂时不用管
        GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL);
        if (window == NULL)
        {
            std::cout << "Failed to create GLFW window" << std::endl;
            glfwTerminate();
            return -1;
        }
    //    通知GLFW将我们窗口的上下文设置为当前线程的主上下文了
        glfwMakeContextCurrent(window);
        
    //    GLAD 是用来管理openGL 的函数指针的。所以在调用任何openGL函数之前我们都需要初始化GLAD。
    //    我们给GLAD传入了用来加载系统相关的OpenGL函数指针地址的函数。GLFW给我们的是glfwGetProcAddress,它根据我们编译的系统定义了正确的函数。
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
        {
            std::cout << "Failed to initialize GLAD" << std::endl;
            return -1;
        }
        //    创建渲染的视口: 我们必须要告诉OpenGl 需要渲染的尺寸大小,即为视口 viewport(),这样openGL 才能知道根据窗口大小显示数据和坐标。
    //    glViewport 前两个参数控制视口左下角位置,后两个参数控制视口的宽和高
    //    openGL 幕后使用的是glViewport 定义的 位置和宽高进行2D转换
        glViewport(0, 0, 800, 600);
    //    窗口调整的时候 视口应该也被调整  对窗口注册一个回调函数每次窗口大小被调整的时候会被调用
        void framebuffer_size_callback(GLFWwindow *window, int width, int height);
        
    
    //   通过 glfwSetFramebufferSizeCallback glfw 函数 当窗口frame 变化时会调用。
    //    对于视网膜屏 Retain 屏   宽度和高度明显比原输入值更高一点。
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
        
        void processInput(GLFWwindow *window);
        
    //   为了防止 渲染的图像一出现就退出 我们使用while 循环 。我们可以称之为Render Loop
    //    glfwWindowShouldClose 每次循环开始前检查一次GLFW 是否被要求退出 是true 的话渲染便结束了。
        while(!glfwWindowShouldClose(window))
        {
            //输出控制
            processInput(window);
    //        glfwSwapBuffers 会交换颜色缓冲(他是存储着GLFW 窗口每一个像素色值的大缓冲),将会作为输出显示在屏幕上
    //        当程序退出的时候 使用一个自定义的颜色清空屏幕  在每个新的渲染迭代可是的时候我们总希望清屏否则总是看到上次渲染的结果。
    //        我们可以使用glClear   GL_COLOR_BUFFER_BIT,GL_DEPTH_BUFFER_BIT和GL_STENCIL_BUFFER_BIT。 我们清空颜色 。
            glClearColor(0.5f, 0.1f, 0.0f, 1.0f);
            glClear(GL_COLOR_BUFFER_BIT);
            glfwSwapBuffers(window);
    //        glfwPollEvents 检查函数有没有触发什么事件 键盘输入 鼠标移动 并调用对应函数
            glfwPollEvents();
        }
    
        
        glfwTerminate();
    
        return 0;
    }
    
    
    void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    {
        glViewport(0, 0, width, height);
    }
    void processInput(GLFWwindow *window)
    {
    //
        if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
            glfwSetWindowShouldClose(window, true);
    }
    

    Mac OSX下搭建OpenGL超级宝典5(蓝宝书)开发环境

    1. 下载OpenGL超级宝典5(蓝宝书)的资源,链接如下:http://pan.baidu.com/s/1c0z9WRm, 解压得到SB5文件夹,里面有书籍的课程源码以及GLTools库。

    2. 依次点击Xcode–>Preferences–>Locations–>Sources Trees,再点“+”号按钮添加Name: GLTOOLS_INCLUDE, Display Name: GLTools include Folder, Path: ~/Desktop/SB5/src/GLTools/include(本人解压的SB5文件夹在桌面,读者可以根据自己情况添加)。

    3. Xcode下新建一个Cocoa工程,命名Triangle,删除项目下得AppDelegate.*两个文件和main.m文件。

    4. 点击项目–>TARGETS–>Build Settings–>Header Search Paths,添加 $(GLTOOLS_INCLUDE);然后同样的点击项目–>TARGETS–>Build Phases–>Link Binary With Libraries,点击“+”号添加,GLUT.framework,OpenGL.framework,点击Add Other添加桌面/SB5/Src/GLTools/libGLTools.a文件(添加以后可能编译不过,可能出现的问题是依赖库的路径没有配置,点击项目–>TARGETS–>Build Settings–>Libraries Search Path添加)

    window OpenGL开发环境搭建

    1. 准备资源

    1. 工具下载地址:
      glew:http://glew.sourceforge.net/ 找到对应本机OpenGL版本的glew
      gluw:https://www.opengl.org/resources/libraries/glut/glutdlls37beta.zip opengl官网上有提供,点击链接直接下载
      VS2017:https://visualstudio.microsoft.com/zh-hans/vs/

    cmake 官网:https://cmake.org/download/

    2. 配置glew

    1. 拷贝glew32.dll至system32文件夹下
    2. 拷贝glew32.lib至VC目录下lib文件夹。我的VS目录地址:D:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.15.26726\lib\x86
    3. 拷贝glew.h和wglew.h至VC目录下include\GL目录下。注意GL文件夹需自己创建(可以直接复制glew解压文件中的GL文件夹)。我的VS目录地址:D:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.15.26726\include
    4. 创建控制台项目,调出VS的资源视图,项目上右击进入属性,链接器-输入-附加依赖项:新加入glew32.lib

    3. 配置glut:

    1. 把.h文件放到VC的include路径下的GL文件夹下
    2. glut.lib和glut32.lib放到VC的lib文件夹下
    3. glut.dll,glut32.dll,放到系统盘下\WINDOWS\system32
    4. 完成后,新建控制台项目,复制进示例源码到.cpp文件即可。源码在下方,注意不要覆盖掉cpp文件的自带的头文件

    配置VS工程如下:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    参考文档:
    https://jingyan.baidu.com/article/636f38bbb8d50cd6b9461065.html

    展开全文
  • OpenGL3.3规范文档

    2020-01-31 16:29:28
    OpenGL3.3规范文档
  • OpenGL开发指南

    2012-05-02 14:54:08
    一个非常实用的介绍OpenGL编程的入门级文档,内容非常丰富,介绍非常详细。该文档易学易用,是从零学习和迅速提高OpenGL编程技术的绝好资料。
  • OpenGL开发

    2014-04-05 21:16:27
    本文件包含VS或VC++配置OpenGL时需要用到的开发库,里面包含一份介绍如何安装这些开发库的文档,以供大家参考。
  • OpenGL 4 API文档

    2020-01-16 00:13:55
    OpenGL 4 API文档OpenGL(英语:Open Graphics Library,译名:开放图形库或者“开放式图形库”)是用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程接口(API)。这个接口由近350个不同的函数调用组成,...
  • 原文地址:http://android.xsoftlab.net/training/graphics/opengl/draw.html如果你还不清楚如何定义图形及坐标系统,请移步:Android官方开发文档Training系列课程中文版:OpenGL绘图之图形定义。在定义了图形之后...

    原文地址:http://android.xsoftlab.net/training/graphics/opengl/draw.html

    如果你还不清楚如何定义图形及坐标系统,请移步:Android官方开发文档Training系列课程中文版:OpenGL绘图之图形定义

    在定义了图形之后,你接下来需要做的就是将它绘制到屏幕上。不过使用OpenGL ES 2.0 API来绘制这个图形所需要的代码量可能要比想象中的多一些,这是因为API为图形渲染管道提供了大量的控制细节。

    这节课会展示如何绘制上节课所定义的图形。

    初始化图形

    在开始任何绘制之前,你必须先初始化并加载这个图形。除非是在执行的过程中图形的结构发生了改变。这个时候你应该在渲染器的onSurfaceCreated()方法中去初始化它们,这样可以使内存和进程的效率提升。

    public class MyGLRenderer implements GLSurfaceView.Renderer {
        ...
        private Triangle mTriangle;
        private Square   mSquare;
        public void onSurfaceCreated(GL10 unused, EGLConfig config) {
            ...
            // initialize a triangle
            mTriangle = new Triangle();
            // initialize a square
            mSquare = new Square();
        }
        ...
    }

    绘制图形

    绘制自定义图形需要大量的代码,因为你必须给图形渲染管道提供大量的渲染细节。尤其是下面这些必须定义:

    • Vertex Shader - 图形顶点的渲染.
    • Fragment Shader - 图形表面的颜色或纹理的渲染。
    • Program - 一个含有多个渲染器的OpenGL ES对象,可以用它来绘制一个或者多个图形。

    你需要至少一个顶点渲染器来绘制图形,并需要一个表面渲染器来为图形着色。这些渲染器首先必须是可执行的,然后才能将其添加到OpenGL ES程序中,这时才能被用来绘制图形。下面定义了一个最基本的可以用来绘制图形的渲染器:

    public class Triangle {
        private final String vertexShaderCode =
            "attribute vec4 vPosition;" +
            "void main() {" +
            "  gl_Position = vPosition;" +
            "}";
        private final String fragmentShaderCode =
            "precision mediump float;" +
            "uniform vec4 vColor;" +
            "void main() {" +
            "  gl_FragColor = vColor;" +
            "}";
        ...
    }

    渲染器包含了OpenGL渲染语言代码,这些代码必须先在OpenGL ES环境中编译通过。为了编译这些代码,需要在渲染器类中创建一个功能方法:

    public static int loadShader(int type, String shaderCode){
        // create a vertex shader type (GLES20.GL_VERTEX_SHADER)
        // or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)
        int shader = GLES20.glCreateShader(type);
        // add the source code to the shader and compile it
        GLES20.glShaderSource(shader, shaderCode);
        GLES20.glCompileShader(shader);
        return shader;
    }

    为了可以绘制图形,必须先编译这些渲染器代码,然后再将其添加到OpenGL程序中,最后再链接到程序中。需要将这些工作放入绘制对象的构造方法中,所以这些工作只用做一次。

    Note: OpenGL ES的编译与链接过程需要消耗较高的CPU资源与时间,所以你应该避免这些工作做多次。如果在程序运行之前不知道渲染器的代码,应该确保这部分的构建代码只会执行一次,并需要将其缓存下来以便稍后使用。

    public class Triangle() {
        ...
        private final int mProgram;
        public Triangle() {
            ...
            int vertexShader = MyGLRenderer.loadShader(GLES20.GL_VERTEX_SHADER,
                                            vertexShaderCode);
            int fragmentShader = MyGLRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER,
                                            fragmentShaderCode);
            // create empty OpenGL ES Program
            mProgram = GLES20.glCreateProgram();
            // add the vertex shader to program
            GLES20.glAttachShader(mProgram, vertexShader);
            // add the fragment shader to program
            GLES20.glAttachShader(mProgram, fragmentShader);
            // creates OpenGL ES program executables
            GLES20.glLinkProgram(mProgram);
        }
    }

    这时就可以真正的开始绘制了。图形的绘制需要提供若干的参数来告诉渲染管道想要绘制什么及如何绘制。因为绘制选项可以定义多种多样的图形形式,所以可以自定义一个拥有独立绘制逻辑的类来绘制各种图形。

    创建一个draw()方法开始绘制这个图形。这部分代码将会为顶点渲染器设置位置数据,并为表面渲染器设置颜色数据。然后开始执行绘制功能。

    private int mPositionHandle;
    private int mColorHandle;
    private final int vertexCount = triangleCoords.length / COORDS_PER_VERTEX;
    private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex
    public void draw() {
        // Add program to OpenGL ES environment
        GLES20.glUseProgram(mProgram);
        // get handle to vertex shader's vPosition member
        mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
        // Enable a handle to the triangle vertices
        GLES20.glEnableVertexAttribArray(mPositionHandle);
        // Prepare the triangle coordinate data
        GLES20.glVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX,
                                     GLES20.GL_FLOAT, false,
                                     vertexStride, vertexBuffer);
        // get handle to fragment shader's vColor member
        mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");
        // Set color for drawing the triangle
        GLES20.glUniform4fv(mColorHandle, 1, color, 0);
        // Draw the triangle
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);
        // Disable vertex array
        GLES20.glDisableVertexAttribArray(mPositionHandle);
    }

    一旦完成以上所有的代码,最后只需要调用一下draw()方法就可以开始绘制了:

    public void onDrawFrame(GL10 unused) {
        ...
        mTriangle.draw();
    }

    当程序启动之后,设备上就会出现以下图形:

    上面的示例代码还有几个问题:首先,它不会给人留下什么深刻的印象。其次,当屏幕旋转的时候,这个三角形会有一点被压扁的感觉。这是因为在旋转的时候,代码中所定义的顶点的相对位置被压缩了。这些问题将会在下节课得到解决。

    最后,这三角形是固定不变的,这会有些让人有些不爽的感觉。在Adding Motion的课程中将会使这个图形可以随着手势旋转而旋转,还可以通过渲染管道做到其它更多有意思的事情。

    展开全文
  • opengl开发库文件

    热门讨论 2013-12-30 11:09:51
    windows下的opengl开发库文件,包含头文件、lib、bin文件,在工程中直接添加即可使用
  • 如果不清楚OpenGL如何绘制自定义图形的相关基础知识时,那么使用OpenGL一定要仔细。这节课将会简单讲述OpenGl ES的坐标系统,及定义图形的基础。本章中以三角形、正方形举例做说明。定义三角形OpenGL

    原文地址:http://android.xsoftlab.net/training/graphics/opengl/shapes.html

    使用OpenGL绘制图形的第一步就是要定义一个图形。如果不清楚OpenGL如何绘制自定义图形的相关基础知识时,那么使用OpenGL一定要仔细。

    这节课将会简单讲述OpenGl ES的坐标系统,及定义图形的基础。本章中以三角形、正方形举例做说明。

    定义三角形

    OpenGL ES允许用户使用三维空间定义绘制的对象。所以,在绘制三角形之前,必须先定义它的坐标。在OpenGL中,最典型的方式就是以浮点型的数字定义一个顶点坐标数组。为了提高效率,应该将这些数据写入到一个ByteBuffer对象中,它随后会被送入OpenGL ES图形管道中,等待处理。

    public class Triangle {
        private FloatBuffer vertexBuffer;
        // number of coordinates per vertex in this array
        static final int COORDS_PER_VERTEX = 3;
        static float triangleCoords[] = {   // in counterclockwise order:
                 0.0f,  0.622008459f, 0.0f, // top
                -0.5f, -0.311004243f, 0.0f, // bottom left
                 0.5f, -0.311004243f, 0.0f  // bottom right
        };
        // Set color with red, green, blue and alpha (opacity) values
        float color[] = { 0.63671875f, 0.76953125f, 0.22265625f, 1.0f };
        public Triangle() {
            // initialize vertex byte buffer for shape coordinates
            ByteBuffer bb = ByteBuffer.allocateDirect(
                    // (number of coordinate values * 4 bytes per float)
                    triangleCoords.length * 4);
            // use the device hardware's native byte order
            bb.order(ByteOrder.nativeOrder());
            // create a floating point buffer from the ByteBuffer
            vertexBuffer = bb.asFloatBuffer();
            // add the coordinates to the FloatBuffer
            vertexBuffer.put(triangleCoords);
            // set the buffer to read the first coordinate
            vertexBuffer.position(0);
        }
    }

    默认情况下,OpenGL ES的坐标系统将[0,0,0](X,Y,Z)点作为GLSurfaceView的中心。[1,1,0]点是框架的右上角,[-1,-1,0]点是框架的左下角。有关该坐标系统的演示信息,请参见OpenGL ES开发指南。

    注意这里定义图形坐标点是以逆时针方向定义的。知道这个绘制顺序是很重要的,因为它决定了图形的哪一面应该是朝着用户的,哪一面应该是被绘制的,以及朝着用户的另一面的绘制信息,它还可以选择不使用OpenGL绘制朝着用户的这一面等功能。有关更多转向及选择绘制的相关信息,请参见OpenGL ES开发指南。

    定义正方形

    定义一个三角形是很容易的,但是定义一些稍微比较复杂一点的图形会怎么样?比如定义一个正方形?这里提供了几种实现方式,但是典型的方式就是将两个三角形绘制到一起,然后形成一个正方形:

    再提醒一次,定义图形的时候应该以逆时针方向定义这两个三角形的顶点。为了避免两个三角形都重复定义两个坐标点,应该使用绘制列表来告诉OpenGL ES绘制管道如何绘制这些顶点。下面是这个图形的代码:

    public class Square {
        private FloatBuffer vertexBuffer;
        private ShortBuffer drawListBuffer;
        // number of coordinates per vertex in this array
        static final int COORDS_PER_VERTEX = 3;
        static float squareCoords[] = {
                -0.5f,  0.5f, 0.0f,   // top left
                -0.5f, -0.5f, 0.0f,   // bottom left
                 0.5f, -0.5f, 0.0f,   // bottom right
                 0.5f,  0.5f, 0.0f }; // top right
        private short drawOrder[] = { 0, 1, 2, 0, 2, 3 }; // order to draw vertices
        public Square() {
            // initialize vertex byte buffer for shape coordinates
            ByteBuffer bb = ByteBuffer.allocateDirect(
            // (# of coordinate values * 4 bytes per float)
                    squareCoords.length * 4);
            bb.order(ByteOrder.nativeOrder());
            vertexBuffer = bb.asFloatBuffer();
            vertexBuffer.put(squareCoords);
            vertexBuffer.position(0);
            // initialize byte buffer for the draw list
            ByteBuffer dlb = ByteBuffer.allocateDirect(
            // (# of coordinate values * 2 bytes per short)
                    drawOrder.length * 2);
            dlb.order(ByteOrder.nativeOrder());
            drawListBuffer = dlb.asShortBuffer();
            drawListBuffer.put(drawOrder);
            drawListBuffer.position(0);
        }
    }

    这个示例展现了如何创建复合型图形的方法。一般情况下,会以三角形堆叠的方式来绘制对象。在下节课中,你会学习到如何在屏幕上绘制这些图形。

    展开全文
  • OpenGL开发手册

    2015-04-20 12:04:34
    技术应该免费分享,拒绝技术垄断! 注:内容来自互联网
  • Opengl开发

    2008-07-14 19:42:40
    开始学习opengl所需要的所有东东,包括FREEglut,glut(带库源码),msopengl,gl和glut的api文档
  • 原文地址:http://android.xsoftlab.net/training/graphics/opengl/index.html 引言 Android framework层为创建绚丽的功能性UI提供了大量的标准工具。...Android framework所提供的OpenGL ES API为我们提供

    原文地址:http://android.xsoftlab.net/training/graphics/opengl/index.html

    引言

    Android framework层为创建绚丽的功能性UI提供了大量的标准工具。然而,如果想要以更多方式来控制屏幕的绘制,或者在三维图形中绘制,那么就需要使用其它工具了。Android framework所提供的OpenGL ES API为我们提供了一系列的工具,这些工具可以用来显示一些高端大气、天马行空的图形,只要你能想得到,那么它就可以做得到。此外,它还得益于很多设备所提供的GPU加速功能。

    这节课会讨论OpenGL的开发基础:包括设置环境、绘制对象、移动绘制元素及响应触摸事件。

    在接下来的示例代码中使用了OpenGL ES 2.0 API,该版本在当前的Android设备上推荐使用。有关更多OpenGL ES的版本信息,请参见OpenGL开发指南。

    Note: 注意不要将OpenGL ES 1.x API与OpenGL ES 2.0 API相混淆!这两个版本的API之间不可交换使用,如果要使用的话,那么只有一个结果,就是悲剧。

    构建OpenGL ES的相关环境

    为了能在Android应用中使用OpenGL ES,必须给OpenGL ES要绘制的图形区域创建一个View容器。其中一种实现方法就是实现GLSurfaceViewGLSurfaceView.Renderer。其中GLSurfaceView是在OpenGL中绘制图形的View容器。GLSurfaceView.Renderer用于控制应该在刚才的View中绘制什么。有关更多这些类的信息,请参见OpenGL ES开发指南。

    GLSurfaceView是将OpenGL ES整合到应用中的唯一途径。对于全屏或者接近全屏的图形View,GLSurfaceView是最合适的选择。开发者如果需要将OpenGL ES整合到一小块区域上,应该使用TextureView。除此之外还可以使用SurfaceView,不过这可能需要相当多的代码才能实现。

    这节课将会展示以最省的代码来实现GLSurfaceView及GLSurfaceView.Renderer。

    在清单文件中声明OpenGL ES的使用

    为了可以使用OpenGL ES 2.0 API,需要在清单文件中添加如下声明:

    <uses-feature android:glEsVersion="0x00020000" android:required="true" />

    如果应用用到了纹理压缩的功能,那么还需要声明应用所使用到的压缩格式,这样的话,应用只能被安装在支持的设备上。

    <supports-gl-texture android:name="GL_OES_compressed_ETC1_RGB8_texture" />
    <supports-gl-texture android:name="GL_OES_compressed_paletted_texture" />

    有关更多纹理压缩格式的相关信息,请参见OpenGL开发指南。

    为OpenGL ES创建一个Activity

    与普通的应用相同,OpenGL ES也同样需要用户界面。主要的不同在于普通的应用只需要将布局放入Activity就可以。在使用OpenGL ES的应用中,除了使用普通的TextView这类基本控件之外,还需要添加GLSurfaceView。

    下面这段代码展示了使用GLSurfaceView的最基本实现:

    public class OpenGLES20Activity extends Activity {
        private GLSurfaceView mGLView;
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            // Create a GLSurfaceView instance and set it
            // as the ContentView for this Activity.
            mGLView = new MyGLSurfaceView(this);
            setContentView(mGLView);
        }
    }

    Note: OpenGL ES 2.0需要在Android 2.2及以上的版本上才能运行,请确保应用程序的最低版本在此之上。

    构建GLSurfaceView对象

    GLSurfaceView是一块特殊的区域,它可以用户绘制OpenGL ES图形。它本身不需要做太多事情。实际上,图形的绘制是由GLSurfaceView.Renderer来控制的。事实上,你可能想要试着不去继承这个类,而是直接创建一个原生的GLSurfaceView实例,不要这么去做。你需要继承这个类来捕获触摸事件,相关信息在Responding to Touch Events课程中有涉及到。

    本质上GLSurfaceView的代码是很少的,所以为了快速去实现它,常见的做法是在使用这个对象的Activity中创建一个内部类:

    class MyGLSurfaceView extends GLSurfaceView {
        private final MyGLRenderer mRenderer;
        public MyGLSurfaceView(Context context){
            super(context);
            // Create an OpenGL ES 2.0 context
            setEGLContextClientVersion(2);
            mRenderer = new MyGLRenderer();
            // Set the Renderer for drawing on the GLSurfaceView
            setRenderer(mRenderer);
        }
    }

    对GLSurfaceView的其它附加选项就是设置其渲染模式:

    // Render the view only when there is a change in the drawing data
    setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);

    这个选项阻止了GLSurfaceView框架的重新绘制,直到requestRender()方法被调用。这可以提高应用的效率。

    构建渲染器类

    GLSurfaceView.Renderer是真正有意思的地方。这个类可以控制在GLSurfaceView上所绘制的事物。它内部有3个方法,这3个方法由Android系统调用,用于计算如何在GLSurfaceView上进行绘制:

    下面是OpenGL ES渲染器的最基本实现,这里只是在GLSurfaceView简单绘制了一个黑色的背景:

    public class MyGLRenderer implements GLSurfaceView.Renderer {
        public void onSurfaceCreated(GL10 unused, EGLConfig config) {
            // Set the background frame color
            GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        }
        public void onDrawFrame(GL10 unused) {
            // Redraw background color
            GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
        }
        public void onSurfaceChanged(GL10 unused, int width, int height) {
            GLES20.glViewport(0, 0, width, height);
        }
    }

    上面就是要做的所有工作了。上面的代码使用OpenGL绘制了一个黑色的背景。虽然这些代码并没有做什么有意思的事情,但是通过创建这些类,你就可以为通过OpenGL绘制图形打下了基础。

    Note: 你可能会怀疑,在使用OpengGL ES 2.0 API时,为什么这些方法都会有个名叫GL10的参数。这些在2.0 API中重复使用到的签名方法是为了保持Android framework的代码简便。

    如果你对OpenGL ES API很熟悉,你现在就可以设置OpenGL ES的环境并着手绘制图形了。无论如何,如果你想获取更多有关OpenGL的入门帮助,可以查看下节上部分的一些小提示。

    展开全文
  • 在屏幕上绘制物体只是OpenGL基础的基础,除了OpenGL,你还可以使用Canvas及Drawable对象做到同样的功能。OpenGL还提供了额外的功能,我们可以使用这些功能在三维空间中移动或者旋转物体,或者以其独有的方式创造绚丽...
  • 原文地址:...但要是能使用户可以直接控制图形的旋转,这才是OpenGL的真正目的。它真正的关键所在就是使程序可以交互式触摸。这主要靠重写GLSurfaceView的onTouchEvent()的方法来实现触
  • openGL入门开发手册

    2011-01-27 16:42:16
    openGL入门开发手册,作为OPENGL开发人员的查询手册非常好用,是PDF格式的文档
  • 在上一篇文章中,我们大致介绍了目前比较主流的OpenGL第三方库的一些类别以及一些主流的第三库的作用,特别的在文章末尾给出了选择OpenGL开发环境的一些建议。目前来说glfw+glad或者glfw+glew是目前OpenGL开发环境的...
  • 1.简介   .stl 文件是在计算机图形应用系统中,用于表示三角形网格的一种文件格式。 它的文件格式非常简单, 应用很广泛。   STL是最多快速原型系统所应用的标准文件类型。STL是用三角网格来表现3D CAD模型。...
  • OpenGL ES环境中,投影相机View可以将所绘制的图形模拟成现实中所看到的物理性状。这种物理模拟是通过改变对象的数字坐标实现的: 投影 - 这基于GLSurfaceView的高宽的坐标转换而实现。如果不采用这种计算,
  • OpenGL开发库 (vc6).zip

    2020-06-29 01:27:32
    含GL.H、GLAUX.H、GLEXT.H、GLU.H、GLUT.H和WGLEXT.H,opengl/opengl32.lib、GLAUX.LIB、glu/glu32.lib、glut/glut32.lib以及相应的DLL文件,附VC环境设置说明文档

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,953
精华内容 10,781
关键字:

opengl开发文档