OpenGL学习二十一：纹理坐标

最新推荐文章于 2024-07-24 19:09:19 发布
最新推荐文章于 2024-07-24 19:09:19 发布
阅读量5.8k 收藏 17
点赞数 5
文章标签： OpenGL 图形
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tiankefeng19850520/article/details/18620779
版权

在纹理贴图场景时，必须为每个顶点提供物体坐标和顶点坐标，经过变换之后，物体坐标决定了应该在屏幕上的那个地点渲染每个特定的顶点，纹理坐标决定了纹理图像中的那个纹理单元将分配给这个顶点
void glTexCoord{1,2,3,4}{sifd} (Type coords);

纹理的放大与缩小

1.原始大小
glTexCoord2f(0.0f, 0.0f); glVertex2f(-1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex2f( 1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex2f( 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex2f(-1.0f, 1.0f);

1.X轴重复（放大与缩小）
glTexCoord2f(0.0f, 0.0f); glVertex2f(-1.0f, -1.0f);
glTexCoord2f(n*1.0f, 0.0f); glVertex2f( 1.0f, -1.0f);
glTexCoord2f(n*1.0f, 1.0f); glVertex2f( 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex2f(-1.0f, 1.0f);

当n=2时 当n=0.5时

2.Y轴重复（放大与缩小）
glTexCoord2f(0.0f, 0.0f); glVertex2f(-1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex2f( 1.0f, -1.0f);
glTexCoord2f(1.0f, n*1.0f); glVertex2f( 1.0f, 1.0f);
glTexCoord2f(0.0f, n*1.0f); glVertex2f(-1.0f, 1.0f);

当n=2时 当n=0.5时

3.纹理水平移动
glBegin(GL_QUADS);
glTexCoord2f(roll+0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 0.0f);
glTexCoord2f(roll+1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 0.0f);
glTexCoord2f(roll+1.0f,1.0f); glVertex3f( 1.0f, 1.0f, 0.0f);
glTexCoord2f(roll+0.0f,1.0f); glVertex3f(-1.0f, 1.0f, 0.0f);
glEnd()
其中roll决定纹理水平移动的幅度，roll应该在0.1之间

4.纹理上下移动
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f+roll); glVertex3f(-1.0f, -1.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f+roll); glVertex3f( 1.0f, -1.0f, 0.0f);
glTexCoord2f(1.0f,1.0f+roll); glVertex3f( 1.0f, 1.0f, 0.0f);
glTexCoord2f(0.0f,1.0f+roll); glVertex3f(-1.0f, 1.0f, 0.0f);
glEnd()
其中roll决定纹理上下移动的幅度，roll应该在0.1之间

纹理的重复与截取

当我们进行纹理放大时，纹理会以重复的形式进行平铺GL_REPEAT，但有时我们希望纹理坐标放大，可纹理并不进行重复的平铺，这就用到了截取GL_CLAMP

纹理重复：
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
下图左边为2*2纹理的重复，右边为1*1纹理


第一个矩形
glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0);
glTexCoord2f(0.0, 2.0); glVertex3f(-2.0, 1.0, 0.0);
glTexCoord2f(2.0, 2.0); glVertex3f(0.0, 1.0, 0.0);
glTexCoord2f(2.0, 0.0); glVertex3f(0.0, -1.0, 0.0);


第二个矩形

glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0);
glTexCoord2f(0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
glTexCoord2f(1.0, 1.0); glVertex3f(3, 1.0, -0);
glTexCoord2f(1.0, 0.0); glVertex3f(3, -1.0, -0);

纹理截取
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP)


第一个矩形

glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0);
glTexCoord2f(0.0, 2.0); glVertex3f(-2.0, 1.0, 0.0);
glTexCoord2f(2.0, 2.0); glVertex3f(0.0, 1.0, 0.0);
glTexCoord2f(2.0, 0.0); glVertex3f(0.0, -1.0, 0.0);


第二个矩形

glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0);
glTexCoord2f(0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
glTexCoord2f(1.0, 1.0); glVertex3f(3, 1.0, -0);
glTexCoord2f(1.0, 0.0); glVertex3f(3, -1.0, -0);

左边的图为2*2纹理放大，右边为1*1纹理放大（原始大小）


glTexParameter*（）函数的参数

参数(pname)值(param)
GL_TEXTURE_WRAP_S
从左至右纹理环绕模式
GL_TEXTURE_WRAP_T
从下至上纹理环绕模式
GL_TEXTURE_WRAP_R
从里至外纹理环绕模式		GL_CLAMP：截取
GL_REPEAT：重复
GL_MIRRORED_REPEAT:镜像重复
GL_CLAMP_TO_EDGE:忽略边框截取
GL_CLAMP_TO_BORDER:代边框的截取
GL_TEXTURE_MAG_FILTERGL_NEAREST或GL_LINEAR
GL_TEXTURE_MIN_FILTERGL_NEAREST 速度快，效果差
GL_LINEAR  计算量大。效果好
GL_NEAREST_MIPMAP_NEAREST 速度快，效果差
GL_LINEAR_MIPMAP_NEAREST
GL_NEAREST_MIPMAP_LINEAR
GL_LINEAR_MIPMAP_LINEAR 计算量大。效果好
GL_TEXTURE_BORDER_COLOR
GL_TEXTURE_PRIORITY(0，1)纹理优先级
GL_TEXTURE_BASE_LEVEL浮点值
GL_TEXTURE_MAX_LEVEL浮点值
GL_TEXTURE_MIN_LOD浮点值
GL_TEXTURE_MAX_LEVEL浮点值
GL_TEXTURE_LOD_BIAS
GL_TEXTURE_COMPARE_MODE
纹理比较模式		GL_COMPARE_R_TO_TEXTURE 深度比较
GL_DEPTH_TEXTURE_MODEGL_RED:R
GL_LUMINANCE:亮度
GL_INSENSITY
GL_ALPHA:A
GL_TEXTURE_COMPARE_FUNC
纹理比较方式		GL_LEQUAL,GL_GEQUAL,GL_LESS,GL_GREATER,GL_EQUAL,
GL_NOTEQUAL,GL_ALWAYS,GL_NEVER
GL_GENERATE_MIAMAP
自动生成多重细节层		GL_TRUE,GL_FALSE

纹理坐标DEMO

#include "header.h"


GLuint	texture[1];			
float rollx=0.0f;
float rolly=0.0f;
bool isX=false;
bool isY=false;
float xdouble=1.0f;
float ydouble=1.0f;


AUX_RGBImageRec *LoadBMP(char *Filename)				
{
	FILE *File=NULL;									

	if (!Filename)									
	{
		return NULL;								
	}

	File=fopen(Filename,"r");							

	if (File)										
	{
		fclose(File);									
		return auxDIBImageLoad(Filename);				
	}

	return NULL;										
}

int LoadGLTextures()									
{
	int Status=FALSE;									

	AUX_RGBImageRec *TextureImage[1];					

	memset(TextureImage,0,sizeof(void *)*1);           	

	
	if (TextureImage[0]=LoadBMP("Data/NeHe.bmp"))
	{
		Status=TRUE;									

		glGenTextures(1, &texture[0]);					

		// Typical Texture Generation Using Data From The Bitmap
		glBindTexture(GL_TEXTURE_2D, texture[0]);
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
	
	
		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
	}

	if (TextureImage[0])									
	{
		if (TextureImage[0]->data)							
		{
			free(TextureImage[0]->data);					
		}

		free(TextureImage[0]);								
	}

	return Status;										
}

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)		
{
	if (height==0)										
	{
		height=1;										
	}

	glViewport(0,0,width,height);						

	glMatrixMode(GL_PROJECTION);						
	glLoadIdentity();									

	// Calculate The Aspect Ratio Of The Window
	gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

	glMatrixMode(GL_MODELVIEW);							
	glLoadIdentity();									
}

int InitGL(GLvoid)										
{
	if (!LoadGLTextures())						
	{
		return FALSE;									
	}

	glEnable(GL_TEXTURE_2D);							
	glShadeModel(GL_SMOOTH);							
	glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
	glClearDepth(1.0f);									
	glEnable(GL_DEPTH_TEST);						
	
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);	
	return TRUE;										
}

void DrawGLScene(GLvoid)									
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	
	glLoadIdentity();									
	glTranslatef(0.0f,0.0f,-5.0f);

	glBindTexture(GL_TEXTURE_2D, texture[0]);

	glBegin(GL_QUADS);
		// Front Face
		glTexCoord2f(0.0f+rollx, 0.0f+rolly); glVertex2f(-1.0f, -1.0f);
		glTexCoord2f(xdouble*1.0f+rollx, 0.0f+rolly); glVertex2f( 1.0f, -1.0f);
		glTexCoord2f(xdouble*1.0f+rollx,ydouble*1.0f+rolly); glVertex2f( 1.0f,  1.0f);
		glTexCoord2f(0.0f+rollx, ydouble*1.0f+rolly); glVertex2f(-1.0f,  1.0f);
	
	glEnd();

	glFlush();
}

void scroll()
{ 
	if(isX)
	{
		rollx+=0.002f;									
		if (rollx>1.0f)							
		{
			rollx-=1.0f;				
		}
	}
	if (isY)
	{
		rolly+=0.002f;									
		if (rolly>1.0f)							
		{
			rolly-=1.0f;				
		}
	}
	glutPostRedisplay();
}

void keyboard(unsigned char key,int x,int y)
{
	switch (key)
	{
	case 'x':
		isX=true;
		isY=false;
	glutIdleFunc(scroll);
		
		break;
	case 'y':
		isY=true;
		isX=false;

	glutIdleFunc(scroll);
		break;
	case 'X':
	 xdouble=xdouble+0.5f;

		break;
	case 'Y':
		isY=true;
	 ydouble=ydouble+0.5f;
		break;
	}


}
int main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
	glutInitWindowSize(640,480);
	glutCreateWindow("纹理坐标");
	glutReshapeFunc(ReSizeGLScene);
	glutDisplayFunc(DrawGLScene);
	glutKeyboardFunc(keyboard);
	InitGL();
	glutMainLoop();
	return 0;
}

纹理截取DEMO 

#include "header.h"

#define	checkImageWidth 64
#define	checkImageHeight 64
static GLubyte checkImage[checkImageHeight][checkImageWidth][4];
static GLubyte otherImage[checkImageHeight][checkImageWidth][4];

static GLuint texName[2];

void makeCheckImages(void)
{
   int i, j, c;
    
   for (i = 0; i < checkImageHeight; i++) {
      for (j = 0; j < checkImageWidth; j++) {
         c = ((((i&0x8)==0)^((j&0x8))==0))*255;
         checkImage[i][j][0] = (GLubyte) c;
         checkImage[i][j][1] = (GLubyte) c;
         checkImage[i][j][2] = (GLubyte) c;
         checkImage[i][j][3] = (GLubyte) 255;
         c = ((((i&0x10)==0)^((j&0x10))==0))*255;
         otherImage[i][j][0] = (GLubyte) c;
         otherImage[i][j][1] = (GLubyte) 0;
         otherImage[i][j][2] = (GLubyte) 0;
         otherImage[i][j][3] = (GLubyte) 255;
      }
   }
}

void init(void)
{    
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel(GL_FLAT);
   glEnable(GL_DEPTH_TEST);

   makeCheckImages();
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

   glGenTextures(2, texName);
   glBindTexture(GL_TEXTURE_2D, texName[0]);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 
                   GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
                   GL_NEAREST);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth,
                checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                checkImage);

   glBindTexture(GL_TEXTURE_2D, texName[1]);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth, 
                checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 
                otherImage);
   glEnable(GL_TEXTURE_2D);
}

void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glBindTexture(GL_TEXTURE_2D, texName[0]);
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0);
   glTexCoord2f(0.0, 4.0); glVertex3f(-2.0, 1.0, 0.0);
   glTexCoord2f(4.0, 4.0); glVertex3f(0.0, 1.0, 0.0);
   glTexCoord2f(4.0, 0.0); glVertex3f(0.0, -1.0, 0.0);
   glEnd();

   glBindTexture(GL_TEXTURE_2D, texName[1]);
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0); glVertex3f(2.5, -1.0, 0.0);
   glTexCoord2f(0.0, 1.0); glVertex3f(2.5, 1.0, 0.0);
   glTexCoord2f(1.0, 1.0); glVertex3f(0.5, 1.0, -0);
   glTexCoord2f(1.0, 0.0); glVertex3f(0.5, -1.0, -0);
   glEnd();
   glFlush();
}

void reshape(int w, int h)
{
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 30.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glTranslatef(0.0, 0.0, -5);
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
   }
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize(250, 250);
   glutInitWindowPosition(100, 100);
   glutCreateWindow("纹理截取");
   init();
   glutReshapeFunc(reshape);
   glutDisplayFunc(display);
   glutKeyboardFunc (keyboard);
   glutMainLoop();
   return 0; 
}


寻找幸存者
关注
  • 5
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
android 纹理坐标原点,OpenGL顶点坐标与纹理坐标
weixin_39979215的博客
05-26 571
引言这里先给自己打个广告，前些天闲来无事，在GitHub Pages上搭建了个博客，基于Jekyll模板搭建的，参考了码志作者的博客模板，在此表示感谢。同时欢迎大家来我的博客捧场。顶点坐标系这里不说Android的坐标系，只分析OpenGL的坐标系，而且本文只分析二维坐标系，三维坐标系不在分析范围。在分析OpenGL顶点坐标系之前，我们先来看一张图。OpenGL_ coordinate.jpg图中...
OpenGL学习笔记：坐标系统
热门推荐
mumufan05的专栏
08-20 1万+
为了将坐标从一个坐标系变换到另一个坐标系，我们需要用到几个变换矩阵，最重要的几个分别是模型(Model)、观察(View)、投影(Projection)三个矩阵。我们的顶点坐标起始于局部空间(Local Space)，在这里它称为局部坐标(Local Coordinate)，它在之后会变为世界坐标(World Coordinate)，观察坐标(View Coordinate)，裁剪坐标(Clip ...
OPenGL笔记--给立方体贴图(纹理)
hw5230的博客
06-15 1147
经过前面的学习，我们已经知道了立方体怎么创建了，接下来学习怎么给立方体贴图；为了将纹理正确的映射到四边形上，您必须：将纹理的​​右上角​​​ 映射到四边形的​​右上角​​；纹理的​​左上角​​​ 映射到四边形的​​左上角​​；纹理的​​右下角​​​ 映射到四边形的​​右下角​​；纹理的​​左下角​​​ 映射到四边形的​​左下角​​；如果映射错误的话，图像显示时可能上下 颠倒，侧向一边或者什么都不是第一个参数是X坐标；0.0 是纹理的左侧、0.5 是纹理的中点、 1.0 是纹理的右侧；
iOS OpenGL 纹理坐标详解
jeffasd的专栏
08-08 5122
//顶点着色器 //v.shader //顶点着色器是一个可编程的处理单元，执行顶点变换、纹理坐标变换、光照、材质等顶点的相关操作，每顶点执行一次。替代了传统渲染管线中顶点变换、光照以及纹理坐标的处理，开发人员可以根据自己的需求自行开发，大大增加了程序的灵活性。 //顶点着色器主要是传入相应的Attribute变量、Uniforms变量、采样器以及临时变量，经过顶点着色器后生成Varying变量
GLSL教程 第6章：纹理映射
最新发布
qq_54098120的博客
07-24 793
纹理映射是计算机图形学中一种用于将图像（纹理）应用到3D模型表面的技术。它使得表面能够显示更复杂的细节和视觉效果，而无需增加模型的几何复杂度。在本章中，我们将深入探讨纹理映射的基本概念、在GLSL中使用纹理的方式，以及如何进行纹理坐标变换和纹理过滤。
opengl纹理坐标
tmljs1988的专栏
07-13 940
纹理贴图是先根据纹理坐标确定纹理的大小,再把纹理经缩放后贴到物体上. 当纹理坐标值大于1时,会重复. 如下图,红色框中的纹理坐标分别为: 左下( 0.5, 0),右下(2.5, 0),右上( 2.5, 1.5),左上(0.5, 1.5),根据图片的大小将其缩放后贴到实际物体表面.
OpenGL之纹理坐标及纹理映射
一个小菜鸡的学习之路
06-11 3020
为了实现纹理贴图我们需要做三件事：将一张贴图加载到OpenGL中，提供纹理坐标和顶点（将纹理对应匹配到顶点上），并使用纹理坐标从纹理中进行取样操作取得像素颜色。由于三角形会被缩放、旋转、平移变换导致最后会以不同的结果投影显示到屏幕上，而且由于camera的不同操作看上去也会很不一样。GPU要做的就是让纹理紧跟三角形图元顶点的移动使其看上去真实（如果纹理看上去明显游离在三角形上产生错位就不真实了）。为实现这个效果开发者需要为每个顶点提供一系列纹理坐标。
[OpenGL] OpenGL的纹理坐标问题
...
05-20 2337
Window系统中，屏幕坐标原点在屏幕的左上角,X轴向右为正,Y轴向下为正.度量单位是象素 OpenGL的定义中，纹理坐标原点在画布的左下角,X轴向右为正,Y轴向上为正 左下角坐标为(0.0f, 0,0f), 右上角坐标为(1.0f, 1.0f)和形状（矩形是否为正方形）无关， 其他位置取0到1之间的一个浮点数插值得到 这也是为什么在Windows平台进行OpenGL编程的...
openglexercise01_opengl_基础openGL图形坐标变换、纹理映射_
10-04
为了将纹理应用到图形上，需要定义纹理坐标，这通常与顶点坐标一起指定，然后使用glEnable(GL_TEXTURE_2D)启用纹理，glBindTexture绑定纹理，最后在顶点着色器中使用纹理坐标和纹理单元来采样纹理。 在...
OpenGL.rar_OPENGL 纹理_Opengl纹理_opengl添加纹理_opengl纹理贴图
09-24
对于初学者，理解纹理坐标系、纹理坐标的范围以及如何正确设置纹理参数都是必要的。 在提供的“OpenGL.txt”文件中，可能包含了上述过程的代码示例，包括纹理加载、创建、绑定和应用的详细步骤。通过研究和理解这段...
opengl动态纹理
10-26
用vc++和openGL做的动态云彩程序，采用纹理贴图，云彩可以快速移动
opengl 纹理UV动画，通过不断地修改纹理UV坐标，实现精灵动画。
10-08
opengl 纹理UV动画，通过不断地修改纹理UV坐标，实现精灵动画。opengl 纹理UV动画，通过不断地修改纹理UV坐标，实现精灵动画。
OpenGL.zip_opengl_site:www.pudn.com_四边形
09-23
纹理映射的坐标系统也是理解的重点，包括纹理坐标系与屏幕坐标系之间的转换。 这个实例是一个很好的起点，帮助初学者理解如何在OpenGL中处理纹理和基本的几何形状。通过研究和运行提供的代码，你可以深入理解纹理...
OpenGL | 纹理坐标及环绕模式
该用户还没想到好的昵称的博客
03-14 896
纹理坐标及环绕模式。
OpenGL纹理-12.5、纹理坐标
weixin_30485799的博客
12-14 239
12.5、纹理坐标 12.5.1 坐标定义 在绘制纹理映射场景时，不仅要给每个顶点定义几何坐标，而且也要定义纹理坐标。经过多种变换后，几何坐标决定顶点在屏幕上绘制的位置，而纹理坐标决定纹理图像中的哪一个纹素赋予该顶点。并且顶点之间的纹理坐标插值与基础篇中所讲的平滑着色插值方法相同。 纹理图像是方形数组，纹理坐标通常可定义成一、二、三或四维形式，称为s，...
【OpenGL从入门到精通（六）】纹理对象与纹理坐标
用可见的方式来记录和分享每一次收获
11-20 226
1.当进行纹理贴图时候，纹理的坐标。 2.
OpenGL纹理坐标
海天鹰
04-16 1550
为了将纹理正确的映射到四边形上，必须将： 纹理的左上角映射到四边形的左上角， 纹理的右上角映射到四边形的右上角， 纹理的右下角映射到四边形的右下角， 纹理的左下角映射到四边形的左下角。 如果映射错误的话，图像显示时可能上下颠倒，侧向一边或者什么都不是。 例如：纹理的左上坐标是 X：0.0，Y：1.0f，四边形的左上顶点是 X：-1.0，Y：1.0。 glTexCoord2f( ...
OpenGL:纹理
肖云鹤的博客
04-02 2287
OpenGL:纹理
opengl 学习纹理
cs821984831的博客
02-24 1348
这会为当前绑定的纹理自动生成所有需要的多级渐远纹理。多级渐远纹理背后的理念很简单：距观察者的距离超过一定的阈值，OpenGL会使用不同的多级渐远纹理，即最适合物体的距离的那个。这样没有任何效果，因为多级渐远纹理主要是使用在纹理被缩小的情况下的：纹理放大不会使用多级渐远纹理，为放大过滤设置多级渐远纹理的选项会产生一个GL_INVALID_ENUM错误代码。注意不要和纹理坐标搞混，纹理坐标是你给模型顶点设置的那个数组，OpenGL以这个顶点的纹理坐标数据去查找纹理图像上的像素，然后进行采样提取纹理像素的颜色。
OpenGL教程：解决纹理坐标颠倒问题与OpenGL发展历程
1. 修改顶点数据的纹理坐标，通过在y坐标上做1减运算（即将y值取反），即`TexCoord = vec2(texCoord.x, 1 - texCoord.y)`，这样可以在代码层面简单地调整纹理坐标的方向。 2. 编辑顶点着色器，内置这种坐标反转逻辑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

寻找幸存者

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

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

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

打赏作者

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

抵扣说明：

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

余额充值