OpenGL纹理映射和光照效果

最新推荐文章于 2024-05-10 10:17:56 发布
最新推荐文章于 2024-05-10 10:17:56 发布
阅读量1w 收藏 17
点赞数 7
分类专栏： android OpenGL开发 OpenGL开发基础 文章标签： float filter constructor buffer import 活动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangkuifeng0118/article/details/7428406
版权

        在前面我们已经可以绘制出一个带有颜色的立方体了，但是这些颜色是系统自带的黄色，绿色等，有时候这并不能满足我们的要求，这时候就需要将纹理映射到立方体上去了。

      为使用纹理，我们需要打开OpenGL的一些开关以启动我们需要的一些功能：

     gl.glEnable(GL10.GL_TEXTURE_2D);

     这个调用是必不可缺的；如果你没有打开此功能，那么你就无法将图像映射到多边形上。它可以在需要时打开和关闭，通常在初始化时打开。   

生成纹理

OpenGL 中的纹理通过一个唯一号引用，通过函数 glBindTexture() 实现。你 可以自己指定这个唯一号，或者通过调用 glGenTextures () 函数生成一个唯一 号。

 // 2.生成纹理ID  
        int[] tmp_tex = new int[1];//尽管只有一个纹理，但使用一个元素的数组  
        //glGenTextures(申请个数，存放数组，偏移值）  
        gl.glGenTextures(1, tmp_tex, 0); //向系统申请可用的，用于标示纹理的ID  
        int texture = tmp_tex[0];

纹理绑定

在为纹理生成名称后，在为纹理提供图像数据之前，我们必须绑定纹理。绑定使得指定纹理处于活动状态。一次只能激活一个纹理。活动的或“被绑定”的纹理是绘制多边形时使用的纹理，也是新纹理数据将加载其上纹理，所以在提供图像数据前必须绑定纹理。

 gl.glBindTexture(GL10.GL_TEXTURE_2D, texture);

绑定纹理数据，传入指定图片
   GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bmp, 0);   

下面看一下完整代码：

 

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

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.Renderer;
import android.opengl.GLU;
import android.opengl.GLUtils;

public class CubeRenderer implements Renderer {  
    
    Bitmap bmp;     
    float box[] = new float[] {  
            // FRONT  
            -0.5f, -0.5f,  0.5f,  
             0.5f, -0.5f,  0.5f,  
            -0.5f,  0.5f,  0.5f,  
             0.5f,  0.5f,  0.5f,  
            // BACK  
            -0.5f, -0.5f, -0.5f,  
            -0.5f,  0.5f, -0.5f,  
             0.5f, -0.5f, -0.5f,  
             0.5f,  0.5f, -0.5f,  
            // LEFT  
            -0.5f, -0.5f,  0.5f,  
            -0.5f,  0.5f,  0.5f,  
            -0.5f, -0.5f, -0.5f,  
            -0.5f,  0.5f, -0.5f,  
            // RIGHT  
             0.5f, -0.5f, -0.5f,  
             0.5f,  0.5f, -0.5f,  
             0.5f, -0.5f,  0.5f,  
             0.5f,  0.5f,  0.5f,  
            // TOP  
            -0.5f,  0.5f,  0.5f,  
             0.5f,  0.5f,  0.5f,  
             -0.5f,  0.5f, -0.5f,  
             0.5f,  0.5f, -0.5f,  
            // BOTTOM  
            -0.5f, -0.5f,  0.5f,  
            -0.5f, -0.5f, -0.5f,  
             0.5f, -0.5f,  0.5f,  
             0.5f, -0.5f, -0.5f,  
        };  
      
    float lightAmbient[] = new float[] { 0.5f, 0.5f, 0.6f, 1.0f };  //环境光  
    float lightDiffuse[] = new float[] { 0.6f, 0.6f, 0.6f, 1.0f };//漫反射光  
    float[] lightPos = new float[] {0,0,3,1};  //光源位置  
/* 
 * 因为进行光照处理，你必须告知系统你定义的模型各个面的方向，以便系统计算光影情况，方向的描述是通过向量点来描述的 
 */   
    float norms[] = new float[] { //法向量数组，用于描述个顶点的方向，以此说明各个面的方向  
            // FRONT  
            0f,  0f,  1f, //方向为(0,0,0)至(0,0,1)即Z轴正方向  
            0f,  0f,  1f,  
            0f,  0f,  1f,  
            0f,  0f,  1f,  
            // BACK  
            0f,  0f,  -1f,  
            0f,  0f,  -1f,  
            0f,  0f,  -1f,  
            0f,  0f,  -1f,  
            // LEFT  
            -1f,  0f,  0f,  
            -1f,  0f,  0f,  
            -1f,  0f,  0f,  
            -1f,  0f,  0f,  
            // RIGHT  
            1f, 0f, 0f,  
            1f, 0f, 0f,  
            1f, 0f, 0f,  
            1f, 0f, 0f,  
            // TOP  
            0f,  1f, 0f,  
            0f,  1f, 0f,  
            0f,  1f, 0f,  
            0f,  1f, 0f,  
            // BOTTOM  
            0f,  -1f, 0f,  
            0f,  -1f, 0f,  
            0f,  -1f, 0f,  
            0f,  -1f, 0f  
        };  
  
      
    float texCoords[] = new float[] { //纹理坐标对应数组  
            // FRONT  
             0.0f, 0.0f,  
             1.0f, 0.0f,  
             0.0f, 1.0f,  
             1.0f, 1.0f,  
            // BACK  
             1.0f, 0.0f,  
             1.0f, 1.0f,  
             0.0f, 0.0f,  
             0.0f, 1.0f,  
            // LEFT  
             1.0f, 0.0f,  
             1.0f, 1.0f,  
             0.0f, 0.0f,  
             0.0f, 1.0f,  
            // RIGHT  
             1.0f, 0.0f,  
             1.0f, 1.0f,  
             0.0f, 0.0f,  
             0.0f, 1.0f,  
            // TOP  
             0.0f, 0.0f,  
             1.0f, 0.0f,  
             0.0f, 1.0f,  
             1.0f, 1.0f,  
            // BOTTOM  
             1.0f, 0.0f,  
             1.0f, 1.0f,  
             0.0f, 0.0f,  
             0.0f, 1.0f  
        };  
  
      
    FloatBuffer cubeBuff;  
    FloatBuffer normBuff;  
    FloatBuffer texBuff;  
      
    float xrot = 0.0f;  
    float yrot = 0.0f;  
      
    /** 
     * 将float数组转换存储在字节缓冲数组 
     * @param arr 
     * @return 
     */  
    public FloatBuffer makeFloatBuffer(float[] arr) {  
        ByteBuffer bb = ByteBuffer.allocateDirect(arr.length * 4);//分配缓冲空间，一个float占4个字节  
        bb.order(ByteOrder.nativeOrder()); //设置字节顺序， 其中ByteOrder.nativeOrder()是获取本机字节顺序  
        FloatBuffer fb = bb.asFloatBuffer(); //转换为float型  
        fb.put(arr);        //添加数据  
        fb.position(0);      //设置数组的起始位置  
        return fb;  
    }  
      
    public CubeRenderer(Context c) {  
        // TODO Auto-generated constructor stub  
        cubeBuff = makeFloatBuffer(box);//转换float数组  
        normBuff = makeFloatBuffer(norms);  
        texBuff = makeFloatBuffer(texCoords);     
        bmp = BitmapFactory.decodeResource(c.getResources(), R.drawable.splash);  
    }  
      
      
    protected void init(GL10 gl) {  
        gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);//设置清屏时背景的颜色，R，G，B，A  
          
        gl.glEnable(GL10.GL_LIGHTING); //启用光照  
        gl.glEnable(GL10.GL_LIGHT0);  //开启光源0  
        //设置光照参数，也可以使用默认的，不设置  
        gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_AMBIENT, lightAmbient, 0);  
        gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_DIFFUSE, lightDiffuse, 0);  
        gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_POSITION, lightPos, 0);  
          
        gl.glNormalPointer(GL10.GL_FLOAT, 0, normBuff);  
        gl.glEnableClientState(GL10.GL_NORMAL_ARRAY);  
          
        //使用纹理步骤：  
        // 1.开启贴图  
        gl.glEnable(GL10.GL_TEXTURE_2D);  
          
        // 2.生成纹理ID  
        int[] tmp_tex = new int[1];//尽管只有一个纹理，但使用一个元素的数组  
        //glGenTextures(申请个数，存放数组，偏移值）  
        gl.glGenTextures(1, tmp_tex, 0); //向系统申请可用的，用于标示纹理的ID  
        int texture = tmp_tex[0];  
          
        //3.绑定纹理，使得指定纹理处于活动状态。一次只能激活一个纹理  
        gl.glBindTexture(GL10.GL_TEXTURE_2D, texture);  
          
        //4.绑定纹理数据，传入指定图片  
        GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bmp, 0);    
          
        //5.传递各个顶点对应的纹理坐标  
        gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, texBuff);  
        gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY); //开启纹理坐标数组  
          
        //6.设置纹理参数 （可选）  
        /*下面的两行参数告诉OpenGL在显示图像时，当它比放大得原始的纹理大  
        *( GL_TEXTURE_MAG_FILTER )或缩小得比原始得纹理小( GL_TEXTURE_MIN_FILTER ) 
        *时OpenGL采用的滤波方式。通常这两种情况下我都采用 GL_LINEAR 。这使得纹理从很远处 
        *到离屏幕很近时都平滑显示。使用 GL_LINEAR 需要CPU和显卡做更多的运算。如果您的机器很慢， 
        *您也许应该采用 GL_NEAREST 。过滤的纹理在放大的时候，看起来马赛克的很。您也可以结合这 
        *两种滤波方式。在近处时使用 GL_LINEAR ，远处时 GL_NEAREST 。 
        **/  
        gl.glTexParameterx(GL10.GL_TEXTURE_2D,GL10.GL_TEXTURE_MAG_FILTER,GL10.GL_LINEAR);     
        gl.glTexParameterx(GL10.GL_TEXTURE_2D,GL10.GL_TEXTURE_MIN_FILTER,GL10.GL_LINEAR);  
              
          
        gl.glEnable(GL10.GL_DEPTH_TEST); //启用深度缓存  
        gl.glEnable(GL10.GL_CULL_FACE);  //启用背面剪裁  
        gl.glClearDepthf(1.0f);    // 设置深度缓存值  
        gl.glDepthFunc(GL10.GL_LEQUAL);  // 设置深度缓存比较函数，GL_LEQUAL表示新的像素的深度缓存值小于等于当前像素的深度缓存值（通过gl.glClearDepthf(1.0f)设置）时通过深度测试     
        gl.glShadeModel(GL10.GL_SMOOTH);// 设置阴影模式GL_SMOOTH  
    }  
      
    @Override  
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {  
        // TODO Auto-generated method stub  
        init(gl);  
    }  
      
    @Override  
    public void onSurfaceChanged(GL10 gl, int w, int h) {  
        // TODO Auto-generated method stub  
        gl.glViewport(0, 0, w, h); //设置视窗  
        gl.glMatrixMode(GL10.GL_PROJECTION); // 设置投影矩阵  
        gl.glLoadIdentity();  //设置矩阵为单位矩阵，相当于重置矩阵         
        GLU.gluPerspective(gl, 45.0f, ((float) w) / h, 0.1f, 10f);//设置透视范围    
    }  
      
    @Override  
    public void onDrawFrame(GL10 gl) {  
        // TODO Auto-generated method stub  
        gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);// 清除屏幕和深度缓存  
          
        gl.glMatrixMode(GL10.GL_MODELVIEW);   //切换至模型观察矩阵  
        gl.glLoadIdentity();// 重置当前的模型观察矩阵  
        GLU.gluLookAt(gl, 0, 0, 3, 0, 0, 0, 0, 1, 0);//设置视点和模型中心位置  
      
        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, cubeBuff);//设置顶点数据  
        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);  
      
        gl.glRotatef(xrot, 1, 0, 0);  //绕着(0,0,0)与(1,0,0)即x轴旋转  
        gl.glRotatef(yrot, 0, 1, 0);  
          
        gl.glColor4f(1.0f, 0, 0, 1.0f);   //设置颜色，红色  
        gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4);  //绘制正方型FRONT面  
        gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 4, 4);  
      
        gl.glColor4f(0, 1.0f, 0, 1.0f);  
        gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 8, 4);  
        gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 12, 4);  
          
        gl.glColor4f(0, 0, 1.0f, 1.0f);  
        gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 16, 4);  
        gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 20, 4);  
      
        xrot += 0.5f;  
        yrot += 0.5f;  
    }  
  
}

上面重要的部分都已经做了注释，下面看一些运行后效果：




码农破圈
关注
  • 7
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenGL和GLSL入门，实现简单的纹理映射，法线映射以及简单光照明模型
weixin_42061607的博客
07-28 2576
OpenGL和GLSL入门，实现简单的纹理映射，法线映射以及简单光照明模型 本人比较懒，技术也比较low，最近读在职研究生的课程，图形学的课程老师要求用着色器实现一个简单的纹理映射和法线映射，因为之前没什么编程基础，很多基本的东西都不会，因此是从零学起，先在网上下载了一个VS2017，学了一下C++，然后按照教程配置GLUT和GLEW，这个比较简单，随便一搜都能搜到，然后就是老师给了一个叫Fre...
opengl纹理映射（上）
04-04
### OpenGL纹理映射详解（上） #### 一、引言 纹理映射是现代计算机图形学中的一个重要概念，尤其在三维图形渲染中占有极其重要的地位。通过纹理映射技术，可以使三维模型表面更加逼真、细腻，从而极大地提升场景...
LearnOpenGL（十）之光照贴图
最新发布
ckg3824278的博客
05-10 826
LearnOpenGL（十）之光照贴图
openGL结合光照与纹理
aoxuestudy的专栏
01-31 1993
展示的面片着色的环面是通过在顶点着色器和片段着色器中，将“flat”插值限 定符添加到相应的法向量属性声明中得到的。这样会使得光栅器不对所限定的变量进行插 值，而是直接将相同的值赋给每个片段（在默认情况下，它会选择三角形第一个顶点上的 值）。在Phong 着色示例代码中，可以通过如下修改实现面片着色：
openGL加载obj三维模型
热门推荐
aoxuestudy的专栏
01-21 1万+
openGL加载obj三维模型，并加入纹理贴图
opengl高级光照-阴影映射
wqdqwass的博客
09-24 742
官方文档 opengl阴影映射 阴影映射（贴图） 阴影映射(Shadow Mapping)背后的思路非常简单：我们以光的位置为视角进行渲染，我们能看到的东西都将被点亮，看不见的一定是在阴影之中了。假设有一个地板，在光源和它之间有一个大盒子。由于光源处向光线方向看去，可以看到这个盒子，但看不到地板的一部分，这部分就应该在阴影中了。 在深度测试教程中，在深度缓冲里的一个值是摄像机视角下，对应于一个片段的一个0到1之间的深度值。如果我们从光源的透视图来渲染场景，并把深度值的结果储存到纹理中会怎样？通过这种方式
Nurbs_opengl_nurbs曲面纹理和光照模型_
10-01
总的来说，"Nurbs_opengl_nurbs曲面纹理和光照模型_"这个主题涵盖了3D图形编程的关键技术，包括NURBS建模、OpenGL的纹理映射以及光照模型的实现。理解并掌握这些知识点对于创建复杂的3D场景和交互式应用程序至关重要...
OpenGL.rar_OPENGL 纹理_OPENGL光照_OpenGL光照纹理_opengl 光照
09-22
最后，通过组合光照和纹理，使得校门在不同光线条件下呈现出丰富的视觉效果。 在压缩包中的“马义鑫”文件可能是作者的名字，也可能是项目代码、日志或其他相关资料。要深入学习和理解这些概念，你可以查看压缩包内...
opengl光照、纹理映射和键盘控制
03-11
做的是把一个旋转立方体的6个面贴上6幅不同的图片，设置了两个键盘控制，一个是通过glutKeyboardFunc(keyboard);来控制灯光的开和关，用glutSpecialFunc(special);来分别改变立方体延x,y,z轴的旋转角度。
OPENGL光照和纹理技术实例.rar
06-28
这个"OPENGL光照和纹理技术实例.rar"压缩包包含了关于如何在OpenGL中应用光照和纹理的关键概念和技术的实例。以下是这些主题的详细解释： 光照在OpenGL中是通过一组称为光源（light sources）的对象来实现的，它们...
基于OpengL的透明纹理映射的实现代码
09-23
在vs2010中利用OpenGL实现透明纹理映射的效果
基于OpengL的环境纹理映射实现
09-23
在vs2010中利用OpenGL实现环境纹理的映射效果
Opengl纹理映射
wymhhgg99的专栏
01-11 1213
9.4 纹理对象 使用纹理对象来存储纹理数据的步骤: 1) 生成纹理对象名称 2) 将纹理对象绑定到纹理数据(包括图像数据数组和纹理属性), 即创建纹理对象. 3) 如果OpenGL实现高性能纹理工作集, 应检查是否有足够的空间来存储所有的纹理对象. 如没有足够空间, 应设置每个纹理对象的优先级, 以确保最常用的纹理留在工作集中 4) 绑定和重新绑定纹理对象, 以便可以将其中的纹理
第十章 opengl之光照（投光物）
Re_view的博客
03-08 1380
第十章 opengl之光照（投光物）
【OpenGL画三角形代码】光滑着色（Gouraud）、深度缓存、透明处理、纹理映射
ccsu_deer
03-22 1610
参考学习资料：视频 【三角形】 【类型】：实心，光滑着色的三角形 【代码】：glShadeModel(GL_SMOOTH); 【引入】：纯色填充 代码： glShadeModel(GL_FLAT); 【效果图】 #include <windows.h> #include <GL\glut.h> void draw() { glClearColor(0.4, 0.5, 0.9, 0.0); //设置清除颜色为黑色 glClea...
OpenGL ES系列 之 提高-2：材质纹理
Carlward 的专栏
05-04 4868
 材质纹理是增加物体表面细节的有效手段。前面我们已经可以加载任意复杂的三维模型了，但是白乎乎的团，看着一点也不酷，现在是时候让它变漂亮一些了。 第一步我们给它上点颜色。首先我们需要对光照模型有点概念，物体看上去有颜色，是它被光线照射的结果，如果光是白色的，那么呈现的就是物体本身的颜色，否则会是光色和表面本色综合的结果。物体表面被点光源照射后，会呈现三个区域：高光区、过渡色区和环境色区。
LearnOpenGL-＞光照-＞投光物/多光源
2201_75303014的博客
02-06 712
LearnOpenGL光照篇的最后两节
OpenGL中phong光照模型详解
aoxuestudy的专栏
06-24 2123
版权 cesuolidec4 https://blog.csdn.net/xiewenzhao123/article/details/54600191 引言 先看phong光照模型中一段顶点着色器的代码 #version 330 core out vec4 FragColor; in vec3 Normal; //法相向量 in vec3 FragPos; // uniform vec3 lightPos; uniform vec3 viewPos; u...
OpenGL光源光照基础
WYN的养生之路的博客
11-10 718
光照模型 在OpenGL光照模型中，除非一个物体自己会发光，否则它将受到3种不同类型的光的照射：环境光(ambient)、散射光(diffuse)和镜面光(specular)。 全局环境光 在我们没有用到光照之前，我们也能够看到场景中绘制的物体，原因是每个场景都有这个全局环境光，它不来自任何特定的光源。 环境光(ambient) 环境光并不来自任何特定的方向。它来自某个光源，但光线却是在房间或场
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值