openGL基础入门（一）

最新推荐文章于 2025-03-24 17:47:16 发布
最新推荐文章于 2025-03-24 17:47:16 发布
阅读量673 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： Android之openGL3.0
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41910103/article/details/83027537

3D图形都是一个个从三角形搭过来的

Triangle类

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import android.annotation.SuppressLint;
import android.opengl.GLES30;
import android.opengl.Matrix;

public class Triangle
{
	public static float[] mProjMatrix = new float[16];//4x4 投影矩阵
    public static float[] mVMatrix = new float[16];//摄像机位置朝向的参数矩阵
    public static float[] mMVPMatrix;//最后起作用的总变换矩阵
	
	int mProgram;//自定义渲染管线程序id
    int muMVPMatrixHandle;//总变换矩阵引用
    int maPositionHandle; //顶点位置属性引用
    int maColorHandle; //顶点颜色属性引用
    String mVertexShader;//顶点着色器代码脚本
    String mFragmentShader;//片元着色器代码脚本
    static float[] mMMatrix = new float[16];//具体物体的移动旋转矩阵，包括旋转、平移、缩放
	
	FloatBuffer   mVertexBuffer;//顶点坐标数据缓冲
	FloatBuffer   mColorBuffer;//顶点着色数据缓冲

    //ByteBuffer  mIndexBuffer;
    int vCount=0;	
    float xAngle=0;//绕x轴旋转的角度
    public Triangle(MyTDView mv)
    {    	
    	//调用初始化顶点数据的initVertexData方法
    	initVertexData();
    	//调用初始化着色器的intShader方法
    	initShader(mv);
    }
   
    public void initVertexData()//初始化顶点数据的方法
    {
    	//顶点坐标数据的初始化
        vCount=36;
        final float UNIT_SIZE=0.15f;
        float vertices[]=new float[]//顶点坐标数组
        {
        	/*-4*UNIT_SIZE,0,0,
        	0,-4*UNIT_SIZE,0,
        	4*UNIT_SIZE,0,0,*/

        	   /* 0,0,0,
                4*UNIT_SIZE,0,4*UNIT_SIZE,
                4*UNIT_SIZE,0,0,
                0,0,0,
                0,0,4*UNIT_SIZE,
                4*UNIT_SIZE, 0,4*UNIT_SIZE,*/

                /*0,0,0,
                4*UNIT_SIZE,4*UNIT_SIZE,0,
                4*UNIT_SIZE,0,0,
                0,0,0,
                0,4*UNIT_SIZE,0,
                4*UNIT_SIZE, 4*UNIT_SIZE,0,*/
                /*-4*UNIT_SIZE,0,0,  //1
                0,-4*UNIT_SIZE,0,  //2
                4*UNIT_SIZE,0,0,   //3


                -4*UNIT_SIZE,0,0,  //4
                4*UNIT_SIZE,0,0,  //5
                0,4*UNIT_SIZE,0,  //6

                -4*UNIT_SIZE,0,0, //7
                0,-4*UNIT_SIZE,0, //8
                -4*UNIT_SIZE,0,4*UNIT_SIZE, //9

                -4*UNIT_SIZE,0,4*UNIT_SIZE, //10
                0,-4*UNIT_SIZE,0 ,//11
                0,-4*UNIT_SIZE,4*UNIT_SIZE, //12

                0,-4*UNIT_SIZE,4*UNIT_SIZE,//13
                0,-4*UNIT_SIZE,0,  //14
                4*UNIT_SIZE,0,0,   //15

                0,-4*UNIT_SIZE,4*UNIT_SIZE,//16
                4*UNIT_SIZE,0,0,   //17
                4*UNIT_SIZE,0,4*UNIT_SIZE,   //18

                0,4*UNIT_SIZE,4*UNIT_SIZE,  //19
                0,4*UNIT_SIZE,0,  //20
                4*UNIT_SIZE,0,0,   //21

                0,4*UNIT_SIZE,4*UNIT_SIZE,  //22
                4*UNIT_SIZE,0,0,   //23
                4*UNIT_SIZE,0,4*UNIT_SIZE,   //24

                -4*UNIT_SIZE,0,4*UNIT_SIZE, //25
                -4*UNIT_SIZE,0,0,  //26
                0,4*UNIT_SIZE,0,  //27

                -4*UNIT_SIZE,0,4*UNIT_SIZE, //28
                0,4*UNIT_SIZE,0,  //29
                0,4*UNIT_SIZE,4*UNIT_SIZE,  //30

                -4*UNIT_SIZE,0,4*UNIT_SIZE, //31
                0,-4*UNIT_SIZE,4*UNIT_SIZE, //32
                4*UNIT_SIZE,0,4*UNIT_SIZE,   //33

                -4*UNIT_SIZE,0,4*UNIT_SIZE, //34
                4*UNIT_SIZE,0,4*UNIT_SIZE,   //35
                0,4*UNIT_SIZE,4*UNIT_SIZE,  //36*/

                -4*UNIT_SIZE,0,0-2*UNIT_SIZE,  //1
                0,-4*UNIT_SIZE,0-2*UNIT_SIZE,  //2
                4*UNIT_SIZE,0,0-2*UNIT_SIZE,   //3


                -4*UNIT_SIZE,0,0-2*UNIT_SIZE,  //4
                4*UNIT_SIZE,0,0-2*UNIT_SIZE,  //5
                0,4*UNIT_SIZE,0-2*UNIT_SIZE,  //6

                -4*UNIT_SIZE,0,0-2*UNIT_SIZE, //7
                0,-4*UNIT_SIZE,0-2*UNIT_SIZE, //8
                -4*UNIT_SIZE,0,4*UNIT_SIZE-2*UNIT_SIZE, //9

                -4*UNIT_SIZE,0,4*UNIT_SIZE-2*UNIT_SIZE, //10
                0,-4*UNIT_SIZE,0-2*UNIT_SIZE,//11
                0,-4*UNIT_SIZE,4*UNIT_SIZE-2*UNIT_SIZE, //12

                0,-4*UNIT_SIZE,4*UNIT_SIZE-2*UNIT_SIZE,//13
                0,-4*UNIT_SIZE,0-2*UNIT_SIZE,  //14
                4*UNIT_SIZE,0,0-2*UNIT_SIZE,   //15

                0,-4*UNIT_SIZE,4*UNIT_SIZE-2*UNIT_SIZE,//16
                4*UNIT_SIZE,0,0-2*UNIT_SIZE,   //17
                4*UNIT_SIZE,0,4*UNIT_SIZE-2*UNIT_SIZE,   //18

                0,4*UNIT_SIZE,4*UNIT_SIZE-2*UNIT_SIZE,  //19
                0,4*UNIT_SIZE,0-2*UNIT_SIZE,  //20
                4*UNIT_SIZE,0,0-2*UNIT_SIZE,   //21

                0,4*UNIT_SIZE,4*UNIT_SIZE-2*UNIT_SIZE,  //22
                4*UNIT_SIZE,0,0-2*UNIT_SIZE,   //23
                4*UNIT_SIZE,0,4*UNIT_SIZE-2*UNIT_SIZE,   //24

                -4*UNIT_SIZE,0,4*UNIT_SIZE-2*UNIT_SIZE, //25
                -4*UNIT_SIZE,0,0-2*UNIT_SIZE,  //26
                0,4*UNIT_SIZE,0-2*UNIT_SIZE,  //27

                -4*UNIT_SIZE,0,4*UNIT_SIZE-2*UNIT_SIZE, //28
                0,4*UNIT_SIZE,0-2*UNIT_SIZE,  //29
                0,4*UNIT_SIZE,4*UNIT_SIZE-2*UNIT_SIZE,  //30

                -4*UNIT_SIZE,0,4*UNIT_SIZE-2*UNIT_SIZE, //31
                0,-4*UNIT_SIZE,4*UNIT_SIZE-2*UNIT_SIZE, //32
                4*UNIT_SIZE,0,4*UNIT_SIZE-2*UNIT_SIZE,   //33

                -4*UNIT_SIZE,0,4*UNIT_SIZE-2*UNIT_SIZE, //34
                4*UNIT_SIZE,0,4*UNIT_SIZE-2*UNIT_SIZE,   //35
                0,4*UNIT_SIZE,4*UNIT_SIZE-2*UNIT_SIZE,   //36

        };
		
        ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length*4);
        vbb.order(ByteOrder.nativeOrder());//设置字节顺序为本地操作系统顺序
        mVertexBuffer = vbb.asFloatBuffer();//转换为浮点(Float)型缓冲
        mVertexBuffer.put(vertices);//在缓冲区内写入数据
        mVertexBuffer.position(0);//设置缓冲区起始位置
        
        float colors[]=new float[]//顶点颜色数组
        {
                1,1,1,0,
                1,1,1,0,
                1,1,1,0,
                1,1,1,0,
                1,1,1,0,
                1,1,1,0,

                1,1,0,0,
                1,1,0,0,
                1,1,0,0,
                1,1,0,0,
                1,1,0,0,
                1,1,0,0,

                1,0,1,0,
                1,0,1,0,
                1,0,1,0,
                1,0,1,0,
                1,0,1,0,
                1,0,1,0,

                1,0,0,0,
                1,0,0,0,
                1,0,0,0,
                1,0,0,0,
                1,0,0,0,
                1,0,0,0,

                0,1,0,0,
                0,1,0,0,
                0,1,0,0,
                0,1,0,0,
                0,1,0,0,
                0,1,0,0,

                0,0,1,0,
                0,0,1,0,
                0,0,1,0,
                0,0,1,0,
                0,0,1,0,
                0,0,1,0,

        		/*1,1,1,0,//白色  1
        		0,0,1,0,//蓝    2
        		0,1,0,0,//绿    3
                1,1,1,0,        //4
                0,1,0,0,       // 5
                0,1,1,0,        //6
                1,1,1,0,    //7
                0,0,1,0,     //8
                1,0,0,0,     //9
                1,0,0,0,   //10
                0,0,1,0,     //11
                1,1,0,0,     //12
                1,1,0,0,     //13
                0,0,1,0,//蓝    14
                0,1,0,0,//绿    15
                1,1,0,0,     //16
                0,1,0,0,//绿    //17
                0.5f,0,0.5f,0,   //18
                0.5f,0.5f,0.5f,0,  //19
                0,1,1,0,        //20
                0,1,0,0,//绿    21
                0.5f,0.5f,0.5f,0,  //22
                0,1,0,0,//绿    23
                0.5f,0,0.5f,0,   //24
                1,0,0,0,     //25
                1,1,1,0,//白色  26
                0,1,1,0,        //27
                1,0,0,0,     //28
                0,1,1,0,        //29
                0.5f,0.5f,0.5f,0,  //30
                1,0,0,0,     //31
                1,1,0,0,     //32
                0.5f,0,0.5f,0,   //33
                1,0,0,0,     //34
                0.5f,0,0.5f,0,   //35
                0.5f,0.5f,0.5f,0,  //36*/
        };
        
        ByteBuffer cbb = ByteBuffer.allocateDirect(colors.length*4);
        cbb.order(ByteOrder.nativeOrder());//设置字节顺序为本地操作系统顺序
        mColorBuffer = cbb.asFloatBuffer();//转换为浮点(Float)型缓冲
        mColorBuffer.put(colors);//在缓冲区内写入数据
        mColorBuffer.position(0);//设置缓冲区起始位置

    }

    //初始化着色器的方法
    @SuppressLint("NewApi")
	public void initShader(MyTDView mv)
    {
    	//加载顶点着色器的脚本内容
        mVertexShader=ShaderUtil.loadFromAssetsFile("vertex.sh", mv.getResources());
        //加载片元着色器的脚本内容
        mFragmentShader=ShaderUtil.loadFromAssetsFile("frag.sh", mv.getResources());  
        //基于顶点着色器与片元着色器创建程序
        mProgram = ShaderUtil.createProgram(mVertexShader, mFragmentShader);
        //获取程序中顶点位置属性引用  
        maPositionHandle = GLES30.glGetAttribLocation(mProgram, "aPosition");
        //获取程序中顶点颜色属性引用
        maColorHandle= GLES30.glGetAttribLocation(mProgram, "aColor");
        //获取程序中总变换矩阵引用
        muMVPMatrixHandle = GLES30.glGetUniformLocation(mProgram, "uMVPMatrix");  
    }
    
    @SuppressLint("NewApi")
	public void drawSelf()
    {        
    	 //指定使用某套shader程序
    	 GLES30.glUseProgram(mProgram);        
    	 //初始化变换矩阵
         Matrix.setRotateM(mMMatrix,0,0,0,1,0);
         //设置沿Z轴正向位移1
         Matrix.translateM(mMMatrix,0,0,0,1);
         //设置绕x轴旋转
         Matrix.rotateM(mMMatrix,0,xAngle,1,0,0);
         //将变换矩阵传入渲染管线
         GLES30.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, Triangle.getFianlMatrix(mMMatrix), 0); 
         //将顶点位置数据传送进渲染管线
         GLES30.glVertexAttribPointer(
         		maPositionHandle,   
         		3, 
         		GLES30.GL_FLOAT, 
         		false,
                3*4,   
                mVertexBuffer
         );
         //将顶点颜色数据传送进渲染管线
         GLES30.glVertexAttribPointer  
         (
        		maColorHandle,
         		4,
         		GLES30.GL_FLOAT,
         		false,
                4*4,
                mColorBuffer
         );
         GLES30.glEnableVertexAttribArray(maPositionHandle);//启用顶点位置数据
         GLES30.glEnableVertexAttribArray(maColorHandle);//启用顶点着色数据  
         //绘制三角形
         GLES30.glDrawArrays(GLES30.GL_TRIANGLES, 0, vCount); 
    }
    public static float[] getFianlMatrix(float[] spec)
    {
    	mMVPMatrix=new float[16];
    	Matrix.multiplyMM(mMVPMatrix, 0, mVMatrix, 0, spec, 0);
        Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mMVPMatrix, 0);        
        return mMVPMatrix;
    }
}

MyTDView类

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
import android.content.Context;
import android.opengl.GLES30;
import android.opengl.GLSurfaceView;
import android.opengl.Matrix;

public class MyTDView extends GLSurfaceView
{
	final float ANGLE_SPAN = 0.375f;
	
	RotateThread rthread;
	SceneRenderer mRenderer;//自定义渲染器的引用
	public MyTDView(Context context)
	{
		super(context);
		this.setEGLContextClientVersion(3);
		mRenderer=new SceneRenderer();
		this.setRenderer(mRenderer);
		this.setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
	}
	private class SceneRenderer implements GLSurfaceView.Renderer
	{
		Triangle tle;
		public void onDrawFrame(GL10 gl)
		{
			//清除深度缓冲与颜色缓冲
            GLES30.glClear( GLES30.GL_DEPTH_BUFFER_BIT | GLES30.GL_COLOR_BUFFER_BIT);
            //绘制三角形对象
            tle.drawSelf();    
		}
		public void onSurfaceChanged(GL10 gl, int width, int height)
		{
			//设置视窗大小及位置 
        	GLES30.glViewport(0, 0, width, height); 
        	//计算GLSurfaceView的宽高比
            float ratio = (float) width / height;
            //调用此方法计算产生透视投影矩阵
            Matrix.frustumM(Triangle.mProjMatrix, 0, -ratio, ratio, -1, 1, 1, 10);
            //调用此方法产生摄像机9参数位置矩阵
            Matrix.setLookAtM(Triangle.mVMatrix, 0, 0,0,3,0f,0f,0f,0f,1.0f,0.0f); 
		}
		public void onSurfaceCreated(GL10 gl, EGLConfig config)
		{
			//设置屏幕背景色RGBA
            GLES30.glClearColor(0,0,0,1.0f);  
            //创建三角形对对象 
            tle=new Triangle(MyTDView.this);        
            //打开深度检测
            GLES30.glEnable(GLES30.GL_DEPTH_TEST);
    		rthread=new RotateThread();
    		rthread.start();
		}
	}
	public class RotateThread extends Thread//自定义的内部类线程
	{
		public boolean flag=true;
		@Override
		public void run()//重写的run方法
		{
			while(flag)
			{
				mRenderer.tle.xAngle=mRenderer.tle.xAngle+ANGLE_SPAN;
				try
				{
					Thread.sleep(20);
				}
				catch(Exception e)
				{
					e.printStackTrace();
				}
			}
		}
	}
}

ShaderUtil 类

import java.io.ByteArrayOutputStream;
import java.io.InputStream;

import android.annotation.SuppressLint;
import android.content.res.Resources;
import android.opengl.GLES30;
import android.util.Log;

//加载顶点Shader与片元Shader的工具类
public class ShaderUtil 
{
   //加载制定shader的方法
   public static int loadShader
   (
		 int shaderType, //shader的类型  GLES30.GL_VERTEX_SHADER(顶点)   GLES30.GL_FRAGMENT_SHADER(片元)
		 String source   //shader的脚本字符串
   ) 
   {
	    //创建一个新shader
        int shader = GLES30.glCreateShader(shaderType);
        //若创建成功则加载shader
        if (shader != 0) 
        {
        	//加载shader的源代码
            GLES30.glShaderSource(shader, source);
            //编译shader
            GLES30.glCompileShader(shader);
            //存放编译成功shader数量的数组
            int[] compiled = new int[1];
            //获取Shader的编译情况
            GLES30.glGetShaderiv(shader, GLES30.GL_COMPILE_STATUS, compiled, 0);
            if (compiled[0] == 0) 
            {//若编译失败则显示错误日志并删除此shader
                Log.e("ES20_ERROR", "Could not compile shader " + shaderType + ":");
                Log.e("ES20_ERROR", GLES30.glGetShaderInfoLog(shader));
                GLES30.glDeleteShader(shader);
                shader = 0;
            }  
        }
        return shader;
    }
    
   //创建shader程序的方法
   public static int createProgram(String vertexSource, String fragmentSource) 
   {
	    //加载顶点着色器
        int vertexShader = loadShader(GLES30.GL_VERTEX_SHADER, vertexSource);
        if (vertexShader == 0) 
        {
            return 0;
        }
        
        //加载片元着色器
        int pixelShader = loadShader(GLES30.GL_FRAGMENT_SHADER, fragmentSource);
        if (pixelShader == 0) 
        {
            return 0;
        }

        //创建程序
        int program = GLES30.glCreateProgram();
        //若程序创建成功则向程序中加入顶点着色器与片元着色器
        if (program != 0) 
        {
        	//向程序中加入顶点着色器
            GLES30.glAttachShader(program, vertexShader);
            checkGlError("glAttachShader");
            //向程序中加入片元着色器
            GLES30.glAttachShader(program, pixelShader);
            checkGlError("glAttachShader");
            //链接程序
            GLES30.glLinkProgram(program);
            //存放链接成功program数量的数组
            int[] linkStatus = new int[1];
            //获取program的链接情况
            GLES30.glGetProgramiv(program, GLES30.GL_LINK_STATUS, linkStatus, 0);
            //若链接失败则报错并删除程序
            if (linkStatus[0] != GLES30.GL_TRUE) 
            {
                Log.e("ES20_ERROR", "Could not link program: ");
                Log.e("ES20_ERROR", GLES30.glGetProgramInfoLog(program));
                GLES30.glDeleteProgram(program);
                program = 0;
            }
        }
        return program;
    }
    
   //检查每一步操作是否有错误的方法
   @SuppressLint("NewApi")
   public static void checkGlError(String op) 
   {
        int error;
        while ((error = GLES30.glGetError()) != GLES30.GL_NO_ERROR) 
        {
            Log.e("ES20_ERROR", op + ": glError " + error);
            throw new RuntimeException(op + ": glError " + error);
        }
   }
   
   //从sh脚本中加载shader内容的方法
   public static String loadFromAssetsFile(String fname,Resources r)
   {
	   	String result=null;    	
	   	try
	   	{
	   		InputStream in=r.getAssets().open(fname);
			int ch=0;
		    ByteArrayOutputStream baos = new ByteArrayOutputStream();
		    while((ch=in.read())!=-1)
		    {
		      	baos.write(ch);
		    }      
		    byte[] buff=baos.toByteArray();
		    baos.close();
		    in.close();
	   		result=new String(buff,"UTF-8"); 
	   		result=result.replaceAll("\\r\\n","\n");
	   	}
	   	catch(Exception e)
	   	{
	   		e.printStackTrace();
	   	}    	
	   	return result;
   }
}

Activity类

import android.app.Activity;
import android.content.pm.ActivityInfo;
import android.os.Bundle;

public class Sample3_1Activity extends Activity//创建继承Activity的主控制类
{
	MyTDView mview;//声明MyTDView类的引用
    @Override
    public void onCreate(Bundle savedInstanceState)//继承Activity后重写的方法
    {
        super.onCreate(savedInstanceState);//调用父类
        //设置为竖屏模式
		setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        mview=new MyTDView(this);//创建MyTDView类的对象
        mview.requestFocus();//获取焦点
        mview.setFocusableInTouchMode(true);//设置为可触控
        setContentView(mview);
    }
    @Override
    public void onResume()//继承Activity后重写的onResume方法
    {
    	super.onResume();
    	mview.onResume();//通过MyTDView类的对象调用onResume方法
    }
    @Override
    public void onPause()//继承Activity后重写的onPause方法
    {
    	super.onPause();
    	mview.onPause();//通过MyTDView类的对象调用onPause方法
    }
}
Opengl入门基础-基础知识
qq_40779012的博客
03-16 9823
opengl入门基础知识，包括：视口创建，着色器编写，光栅化解释等等内容，本文对opengl整体流程进行了简单介绍，通过代码来描述，并具体解释了opengl的相关图形知识，便于初学者对opengl整体上有大概印象，后面的opengl知识会在此基础中进行深度和广度的扩展。
给自己看的OpenGL基础入门教学
weixin_46390192的博客
05-30 1193
一份粗略的OpenGL(Glad+GLFW3)的入门指导教程——>给我自己看的 只是为了完成某门2学分但有四个大作业的可成(っ °Д °;)っ
OpenGL 基础入门
TremendousTurtle的博客
04-30 213
OpenGL 需要用到的数学知识： 空间解析几何，矢量代数。 世界坐标系： 有三维 x,y,z 轴，是 右手坐标系。 向量：在一个坐标系中，两个点位置之间的差，可认为是一个有向线段。 矩阵： 由mxn个数排成的m行n列的数表。 对于OpenGL刚...
OpenGL入门
最新发布
深之JohnChen的专栏
03-24 870
在Windows下推荐使用Visual Studio的vcpkg包管理工具进行安装，Linux下通过apt-get安装相关依赖‌。管理顶点属性指针配置的容器，简化顶点数据格式的切换。处理顶点坐标变换，例如MVP（模型-视图-投影）矩阵运算，输出裁剪空间坐标‌。需通过信号槽或条件变量控制渲染线程与UI线程的同步，避免上下文竞争‌。使用 VAO/VBO 封装顶点属性（位置、纹理坐标）‌，通过。存储顶点索引数据，实现顶点复用，减少重复数据占用显存‌。，且上下文必须在目标线程内创建和激活‌。
OpenGL 入门（一）—— OpenGL 基础
tmacfrank
05-01 1万+
OpenGL（Open Graphics Library）是图形领域的工业标准，是一套跨编程语言、跨平台、专业的图形编程（软件）接口。它用于二维、三维图像，是一个功能强大，调用方便的底层图形库。它与硬件无关，可以在不同的平台如 Windows、Linux、Mac、Android、IOS 之间进行移植。因此，支持 OpenGL 的软件具有很好的移植性，可以获得非常广泛的应用（比如 PS 在部分功能和操作中使用 OpenGL 加速，以提高图像处理和渲染的性能）。对于 Android 系统而言，它支持的是 Ope
OpenGL 基础
weixin_30493321的博客
11-24 112
1.OpenGL概念: OpenGL可以说是一个图形软件开发包,一套函数库,或者一套API.它提供了100多个图形操作函数.2.OpenGL工作流程: OpenGL独立于硬件,以流水线的工作方式.输入OpenGL的可以是图像或者几何元,最终结果都是光栅化后的图像. 对于图像,OpenGL首先通过像素解包把其像素格式转换成OpenGL内部格式,然后通过像素操作直接光栅化输出或作为其他物体的表面...
Open GL es 学习（一）
勇于尝试，却要三思后行。
10-16 735
试试
OpenGL入门一：基础知识及概念
轻口味的专栏
08-11 1457
OpenGL：open graphic library，即开发图形库。它被定义为“图形硬件的一种软件接口”。实质上是3D图形和模型库，它具有高度可移植性，并且具有非常快的速度。可以创建优雅漂亮的3D图形，具有出色的视觉质量。并且速度远快于光线追踪仪或软件渲染引擎。本文介绍了OpenGL相关的知识：OpenGL历史、OpenGL发展、OpenGL应用等，并且介绍了OpenGL需要掌握的知识，OpenGL变换原理及投影成像原理。
opengl 基础入门手册（比较老）
10-12
opengl 基础入门手册（比较老）
OpenGL极速入门宝典.rar_opengl_opengl入门
09-19
本资源“OpenGL极速入门宝典”旨在为初学者提供一个快速掌握OpenGL基础知识的途径，帮助他们步入图形编程的世界。 OpenGL是一个跨语言、跨平台的编程接口，它的主要任务是管理图形硬件，如显卡，以便高效地绘制复杂...
OpenGL基础
Happy Coding!
03-05 686
一：OpenGL和OpenGL ES简介 1.OpenGL:全称是（Open Graphics Library）一个开放的图形库，提供了跨平台，跨语言的图形程序接口。 2.OpenGL应用领域：视频、图像、图片处理；2D/3D游戏引擎开发；科学可视化；医学软件的开发；CAD（计算机辅助技术）；虚拟实境（AR VR）;人工智能等等 3.OpenGL ES:（OpenGL for Embedded S...
Java OpenGL（JOGL）学习笔记，含代码
03-08
在我学习JOGL的时候，只找到了英文版的pdf资料，看不懂。。然后我找了C语言版的OpenGL学习教程，对照着将JOGL学完了，并写了一个word作为笔记
OpenGL入门教程pdf(最基础)
12-19
我在学这个教程 虽然是pdf版本 但比视频更清楚更有目的性 每学一课都想自己实践 很有兴趣 不会枯燥 看完这个再看蓝宝书 效果更好
Java程序中的OpenGL（JOGL学习教程）
05-29
Java程序中的OpenGL（JOGL学习教程）
JAVA的OPENGL，JOGL入门例子（四）----富视觉的螺旋体
07-26
NULL 博文链接：https://wjyjimy.iteye.com/blog/659837
OpenGL入门学习
热门推荐
XscKernel的专栏 记录工作中做的点滴
12-04 2万+
环境搭建 OpenGL入门学习二 点直线和多边形 在OpenGL中指定顶点 开始绘制 例一画一个圆 例二画一个五角星 例三画出正弦函数的图形 OpenGL入门学习三 关于点 关于直线 关于多边形 OpenGL入门学习四 RGBA颜色 索引颜色 指定清除屏幕用的颜色 指定着色模型 OpenGL入门学习五 模型变换和视图变换 投影变换 视口变换 操作矩阵堆栈 综合举例 OpenGL入门学习六 双缓冲技术
openGL 基础知识
zhaogengzi的专栏
07-05 370
openGL 上下文 context 在应用程序调用任何OpenGL的指令之前，首先需要创建一个OpenGL的上下文。这个上下文是一个状态机，保存了OpenGL中的各种状态，这也是OpenGL指令执行的基础。 切换上下文往往会产生较大的开锁，但是不同的绘制模块，可能需要使用独立的状态管理。因此，可以在应用程序中分别创建多个不同的上下文，在不同的线程中使用不同的上下文，上下文之间共享纹理，缓冲区资源，这样的方案比返回切换上下文，大量修改渲染状态，更加合理高效。 渲染 将图形数据转换成3D空间图像 顶
OpenGL基础知识（一）
想飞的企鹅
04-22 784
一、OpenGL是什么?1、OpenGL是一种应用程序编程接口，它是一种可以对图形硬件设备特性进行访问的软件库。2、OpenGL被设计为一个现代化的、硬件无关的接口，因此我们可以在不考虑计算机操作系统或窗口系统的前提下，在多种不同的图形硬件系统上，或者完全通过软件的方式实现OpenGL接口。3、OpenGL自身并不包含任何执行窗口任务，或者处理用户输入的函数。4、OpenGL没有提供用于表达三维物...
OpenGL基础教程
qq_33934427的博客
09-26 1万+
OpenGL基础教程
OpenGL基础入门教程精讲
3. OpenGL基础概念：包括顶点、图元、着色器、缓冲区等重要概念的讲解，以及它们在OpenGL渲染流程中的作用和相互之间的关系。 4. 基本图形绘制：介绍如何使用OpenGL绘制基本图形如点、线、多边形，以及如何处理顶点...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

黑瞳丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值