OpenGL图像纹理和和函数纹理

于 2024-04-23 02:19:07 发布
阅读量161 收藏
点赞数 1
分类专栏： 计算机图形学OpenGL 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_73913334/article/details/138100541
版权

在三维空间中，实现物体表面纹理的绘制，通过菜单完成:

  1. 图像纹理
  2. 函数纹理
  3. 退出

#include <iostream>
#include <cmath>
#include<windows.h>
#include<stdlib.h>
#include<gl/glut.h>
#include<stdio.h>
#include<math.h> //X86
#include<glaux.h>
#pragma comment(lib, "glaux")

#define Width 32
#define Height 32
GLubyte texImage[Height][Width][3];

float rot = 0;
GLuint texture[6];
GLuint texture2[1];
int yourselect;

void Init();
void Reshape(int w, int h);
void LoadGLTextures();
void Loadfunctt();
void makeTexture();
void myDisplay();
void idle();
void menu(int menultem);


void Init()
{
	glClearColor(0.0f, 0.0f,0.1f, 0);//清除颜色函数。会清除（即绘制）的背景色。
	glCullFace(GL_BACK);//背面不可见
	glEnable(GL_CULL_FACE);//裁剪
	glEnable(GL_TEXTURE_2D);//开启纹理
}

void Reshape(int w, int h)
{
	glViewport(0, 0, w, h);
	glMatrixMode(GL_PROJECTION);
	//glMatrixMode设置接下来的矩阵操作为投影矩阵或模型视图矩阵
	//GL_PROJECTION参数用于设置接下来的操作为投影矩阵，GL_MODELVIEW参数则用于设置接下来的操作为模型视图矩阵。
	//投影矩阵定义了从视点到裁剪平面的映射，决定了哪些物体可以被渲染以及它们在窗口中的位置。
	//	模型视图矩阵则定义了物体在空间中的位置、旋转和缩放。
	glLoadIdentity();

	glOrtho(-w / 2, w / 2, -h / 2, h / 2, -300, 300);//设置一个二维的正交投影矩阵。void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}


void LoadGLTextures()
{
	AUX_RGBImageRec* someImage[6];//几幅图
	memset(someImage, 0, sizeof(void*) * 6);
	someImage[0] = auxDIBImageLoad("picture_of_bmp\\bzh.bmp");
	someImage[1] = auxDIBImageLoad("picture_of_bmp\\bzhs.bmp");
	someImage[2] = auxDIBImageLoad("picture_of_bmp\\bzhh.bmp");
	someImage[3] = auxDIBImageLoad("picture_of_bmp\\bzhc.bmp");
	someImage[4] = auxDIBImageLoad("picture_of_bmp\\bzhc.bmp");
	someImage[5] = auxDIBImageLoad("picture_of_bmp\\bzhh.bmp");
	/*for (int i = 0; i < 6; i++) {
		someImage[i] = auxDIBImageLoad("picture_of_bmp\\bzhbzh.bmp");
	}*/
	
	for (int i = 0; i < 6; i++) {
		if (someImage[i])                         //纹理是否存在********
		{
			/*printf("times of for :%d\n",i);///ttt
			printf("2\n");///ttttt*/
			glGenTextures(1, &texture[i]);           //创建纹理
			glBindTexture(GL_TEXTURE_2D, texture[i]); //绑定纹理
			glTexImage2D(GL_TEXTURE_2D, 0, 3, someImage[i]->sizeX, someImage[i]->sizeY, 0,GL_RGB, GL_UNSIGNED_BYTE, someImage[i]->data);//GL_TEXTURE_2D用于渲染2D图像或贴图到3D模型上。//纹理对象的类型,分辨率级别，3代表rgb,长，款，边框，数据格式和数据类型，一个指向内存中图像数据的指针。
			
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);//设置纹理参数//纹理对象的类型，纹理参数的名称，
			free(someImage[i]); //someImage[i] = NULL;//释放图像结构变量占用的内存
		}//glGenTextures函数创建纹理对象，然后使用glBindTexture函数将纹理对象绑定到当前的纹理单元上。接着使用glTexImage2D函数将图像数据传递给纹理对象，其中包括图像的分辨率、格式和数据。//最后使用glTexParameteri函数设置纹理参数，例如纹理过滤器和纹理环绕方式。最后使用free函数释放图像结构变量占用的内存。
		else {
			printf("不存在");
		}
	}
}

void makeTexture() {
	int c;
	for (int i = 0; i < Height; i++)
	{
		for (int j = 0; j < Width; j++) {
			c = (((i & 0x32) == 0) ^ ((j & 0x32)) == 0) * 255;
			texImage[i][j][0] = (GLubyte)c;
			texImage[i][j][1] = (GLubyte)c;
			texImage[i][j][2] = (GLubyte)c;
		}
	}
}
void Loadfunctt() {  //函数纹理
	makeTexture();
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);//像素传输
	glGenTextures(1, &texture2[0]);
	glBindTexture(GL_TEXTURE_2D, texture2[0]); //绑定纹理
	glTexImage2D(GL_TEXTURE_2D, 0, 3, Width, Height, 0, GL_RGB, GL_UNSIGNED_BYTE, texImage);//贴图
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}

void myDisplay()
{
	glClear(GL_COLOR_BUFFER_BIT);
	glLoadIdentity();
	glRotatef(rot, 1, 0, 0);
	glRotatef(rot, 0, 1, 0);
	glRotatef(rot, 0, 0, 1);

	glutWireCube(200);

	if (yourselect == 1) {
		LoadGLTextures();
		glBindTexture(GL_TEXTURE_2D, texture[0]);//front
		glBegin(GL_QUADS);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(-100, -100, 100);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(100, -100, 100);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(100, 100, 100);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(-100, 100, 100);
		glEnd();

		glBindTexture(GL_TEXTURE_2D, texture[1]);//back
		glBegin(GL_QUADS);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(-100, -100, -100);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(-100, 100, -100);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(100, 100, -100);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(100, -100, -100);
		glEnd();

		glBindTexture(GL_TEXTURE_2D, texture[2]);//top
		glBegin(GL_QUADS);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(-100, 100, -100);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(-100, 100, 100);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(100, 100, 100);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(100, 100, -100);
		glEnd();

		glBindTexture(GL_TEXTURE_2D, texture[3]);//bottom
		glBegin(GL_QUADS);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(-100, -100, -100);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(100, -100, -100);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(100, -100, 100);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(-100, -100, 100);
		glEnd();

		glBindTexture(GL_TEXTURE_2D, texture[4]);//right
		glBegin(GL_QUADS);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(100, -100, -100);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(100, 100, -100);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(100, 100, 100);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(100, -100, 100);
		glEnd();

		glBindTexture(GL_TEXTURE_2D, texture[5]);//left
		glBegin(GL_QUADS);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(-100, -100, -100);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(-100, -100, 100);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(-100, 100, 100);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(-100, 100, -100);
		glEnd();
		glFlush();
		glutSwapBuffers();
	//glutWireSphere(100, 16, 16);
		//LoadGLTextures();
		//for (int i = 0; i < 6; i++) {
		//	glClear(GL_COLOR_BUFFER_BIT);
		//	//printf("5\n");
		//	if (i <= 1) {
		//		printf("6\n");
		//		glBindTexture(GL_TEXTURE_2D, texture[i]);//绑定
		//		glBegin(GL_QUADS);//平面四边形
		//		glTexCoord2f(0, 0);//z=+-100的面
		//		glVertex3f(-100, -100, pow(-1, i) * 100);
		//		glTexCoord2f(1, 0);
		//		glVertex3f(100, -100, pow(-1, i) * 100);
		//		glTexCoord2f(1, 1);
		//		glVertex3f(100, 100, pow(-1, i) * 100);
		//		glTexCoord2f(0, 1);
		//		glVertex3f(-100, 100, pow(-1, i) * 100);
		//		glEnd();
		//		//glFlush();
		//		//glutSwapBuffers();//在双缓冲窗口系统中交换前缓冲区和后缓冲区
		//	}
		//	else if (i > 1 && i <= 3) {
		//		glBindTexture(GL_TEXTURE_2D, texture[i]);
		//		printf("7\n");
		//		glBegin(GL_QUADS);//平面四边形
		//		glTexCoord2f(1, 0);//x=100的面
		//		glVertex3f(pow(-1, i) * 100, -100, 100);
		//		glTexCoord2f(0, 0);//
		//		glVertex3f(pow(-1, i) * 100, -100, -100);
		//		glTexCoord2f(1, 1);
		//		glVertex3f(pow(-1, i) * 100, 100, -100);
		//		glTexCoord2f(0, 1);
		//		glVertex3f(pow(-1, i) * 100, 100, 100);

		//		glEnd();
		//		//glFlush();
		//		//glutSwapBuffers();//在双缓冲窗口系统中交换前缓冲区和后缓冲区
		//	}
		//	else if (i > 3 && i <= 5) {
		//		glBindTexture(GL_TEXTURE_2D, texture[i]);
		//		printf("8\n");
		//		glBegin(GL_QUADS);//平面四边形
		//		glTexCoord2f(1, 0);//y=100的面
		//		glVertex3f(-100, 100, pow(-1, i) * 100);
		//		glTexCoord2f(0, 0);//
		//		glVertex3f(-100, -100, pow(-1, i) * 100);
		//		glTexCoord2f(1, 1);
		//		glVertex3f(100, -100, pow(-1, i) * 100);
		//		glTexCoord2f(0, 1);
		//		glVertex3f(100, 100, pow(-1, i) * 100);

		//		glEnd();
		//		//glFlush();
		//		//glutSwapBuffers();//在双缓冲窗口系统中交换前缓冲区和后缓冲区
		//	}
		//	//在双缓冲窗口系统中交换前缓冲区和后缓冲区
		//}
		//glFlush();
		//glutSwapBuffers();
	}
	else if (yourselect == 2) {
		//glClear(GL_COLOR_BUFFER_BIT);
		
		Loadfunctt();//函数纹理
		glutSolidTeapot(200);
		//glutWireCube(200);
		
		glutSwapBuffers();
	}
	else if (yourselect == 3) {
		exit('End');
		
	}
//		glScalef(1.5*k, 1.5*k, 1.5*k);
//		glutWireSphere(100, 16, 16);
//		glRotatef(10*k, 0.0, 0.0, 1.0);
		
	//printf("9\n");

}
void idle()
{
	rot += 1;
	glutPostRedisplay();//
	Sleep(50);
}
void menu(int menultem) {
	yourselect = menultem;
	glutPostRedisplay();
}

int main(int argc, char* argv[])
{
	glutInit(&argc, argv);

	// 在这里设置双缓冲区。        
	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(600, 600);
	glutCreateWindow("TEXTURE");
	//glutMouseFunc(myMouse);
	Init();
	int menuld = glutCreateMenu(menu);
	glutAddMenuEntry("picture_grain", 1);
	glutAddMenuEntry("functon_grain", 2);
	glutAddMenuEntry("End", 3);
	glutAttachMenu(GLUT_RIGHT_BUTTON);
	
	
	//glutIdleFunc(RenderScene);
	glutDisplayFunc(myDisplay);
	glutReshapeFunc(Reshape);

	glutIdleFunc(idle);
	glutMainLoop();//
	return 0;
}

结果展示：

【Mac Technology Overview】（二） Creating Software Products for the Mac Platform（在 Mac 平台上开发应用）
AI工程化、开源分享、文档翻译、代码笔记
12-19 426
1
OpenGL纹理
krais_wk的博客
07-20 981
OpenGL纹理 我们了解到，为了给我们的对象添加更多细节，我们可以使用每个顶点的颜色来创建一些有趣的图像。然而，为了获得相当的真实感，我们必须有很多顶点，以便我们可以指定很多颜色。这会占用相当多的额外开销，因为每个模型都需要更多的顶点，并且每个顶点还需要一个颜色属性。 艺术家和程序员通常更喜欢使用质地. 纹理是用于向对象添加细节的 2D 图像（甚至存在 1D 和 3D 纹理）；把纹理想象成一张纸，上面有漂亮的砖块图像，整齐地折叠在你的 3D 房子上，这样你的房子看起来就像是石头外墙。因为我们可以在单个图像
OpenGL 纹理
renai2008的专栏
07-31 2737
大概步骤: 1.创建纹理对象,并为他指定一个纹理. 2.确定纹理如何应用到每个像素上. 3.启用纹理贴图 4.绘制场景,提供纹理和几何坐标 过滤:由于我们提供的纹理图像很少能和最终的屏幕坐标形成对应,大小不同,所以需要设置过滤项目.允许我们进行插值或者匀和,指定放大缩小的函数.glTexParameter*(),使用过滤模式GL_NEAREST那么纹理单位最邻近的
opengl纹理
qq_58665528的博客
10-23 249
为了能够把纹理映射(Map)到三角形上，我们需要指定三角形的每个顶点各自对应纹理的哪个部分。这样每个顶点就会关联着一个纹理坐标(Texture Coordinate)，用来标明该从纹理图像的哪个部分采样（译注：采集片段颜色）。之后在图形的其它片段上进行片段插值(Fragment Interpolation)。 纹理坐标在x和y轴上，范围为0到1之间（注意我们使用的是2D纹理图像）。使用纹理坐标获取纹理颜色叫做采样(Sampling)。纹理坐标起始于(0, 0)，也就是纹理图片的左下角，终始于(1, 1).
OpenGL和GLSL入门，实现简单的纹理映射，法线映射以及简单光照明模型
weixin_42061607的博客
07-28 2701
OpenGL和GLSL入门，实现简单的纹理映射，法线映射以及简单光照明模型 本人比较懒，技术也比较low，最近读在职研究生的课程，图形学的课程老师要求用着色器实现一个简单的纹理映射和法线映射，因为之前没什么编程基础，很多基本的东西都不会，因此是从零学起，先在网上下载了一个VS2017，学了一下C++，然后按照教程配置GLUT和GLEW，这个比较简单，随便一搜都能搜到，然后就是老师给了一个叫Fre...
大作业——OpenGL-基于物理的渲染挂线项目说明书
Le11eL的博客
06-19 2238
对LearnOpenGL的总结，将各种OPenGL的知识点进行整合，初步实现一个简易的渲染管线。
WebGL自学教程——WebGL示例：3. 纹理三角形
tiewen的专栏
10-22 8954
3. 纹理三角形 　     上章中的三角形虽然看起来比较鲜艳，但很多时候并不实用。我们想在三角形上显示一幅图片，或者更恰当点说，我们想让一张图片中和三角形对应的那一部分显示出来。这可以通过实用纹理图像来实现。这是本章的目的。     为了让WebGL可以访问我们指定图像数据，我们需要将图像数据保存到WebGL内部的纹理对象中。首先，我们要创建纹理对象，使用WebGL函数createText
android 特效相机实现,安卓特效相机(三) OpenGL ES 特效渲染
weixin_35182280的博客
05-29 840
系列文章:特效的实现原理接下来这篇文章我们讲下特效的具体实现原理。由于预览画面的渲染是将Surface传给CameraDevice由它去绘制的,而且我没有找到什么可以接管或者添加渲染效果的接口,所以并不能直接去处理摄像头的画面。于是这里我们只能用一种游戏中常用的手段去处理,这种手段的名字叫做RTT(render to texture),中文名叫做渲染到纹理。玩法是先将我们想要处理的画面,不直接绘制...
立方体函数纹理映射算法
10-17
图形学中关于纹理映射的一种方法,函数纹理映射. 算法的实例中被映射的物体是一个立方体,纹理是一个函数纹理图像,代码完成了把立方体的各个面映射为函数图像.编译环境是VC++ 6 .0 ，属MFC编程。
OpenGL-纹理
weixin_45054115的博客
09-08 923
OpenGL 纹理
openGL之纹理
lzz555517的博客
09-06 2287
opengl纹理相关介绍
[OpenGL]OpenGL纹理
用01改变世界
06-19 1200
1.纹理 纹理是一个2D图片，甚至有可能是1D 和3D纹理，纹理是用来添加物体的细节，可以想象纹理是一张绘有砖块的纸，贴在一面白色的墙上，这样看起来墙就有砖块外表了。 纹理除了图像以外，纹理可以被用来存储大量的数据，这些数据可以发送到着色器上 纹理坐标在x和y轴上，范围为[0,1]（用的2D纹理图像），使用纹理坐标获取纹理颜色叫做采样，纹理坐标起始于（0，0），也就是纹理图片的左下角，终于（1，1...
opengl--纹理
蓝蓝的天
10-16 409
纹理-1维 绑定1维纹理 void LoadAllTextures(void) { static unsigned char roygbiv_image[8][3] = { { 0x3f, 0x00, 0x3f }, /* Dark Violet (for 8 colors…) */ { 0x7f, 0x00, 0x7f }, /* Violet */ { 0xbf, 0x00, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值