GLSL层卷积（中间结果回传）

最新推荐文章于 2023-04-10 15:14:28 发布
最新推荐文章于 2023-04-10 15:14:28 发布
阅读量276 收藏 1
点赞数
分类专栏： GLSL 文章标签： GLSL层卷积
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/juebai123/article/details/108553318
版权
在Pudn.com 复制了一个 ”helloGPGPU_GLSL.cpp“ ,在《GPU通用计算——从Hello GPGPU开始》一文中有中文注解。该程序中 使用了一个纹理，用来保存着色器中间数据并再传着色器。这里也用1个纹理来回传中间结果相加，其它7个纹理用于卷积。生成一个空数据纹理：//加法纹理void initadd(){ float * TexData= new float[imgWidth * imgHeight]; memset(TexData, 0,img.
摘要由CSDN通过智能技术生成

在Pudn.com 复制了一个 ”helloGPGPU_GLSL.cpp“ ,并在《GPU通用计算——从Hello GPGPU开始》一文中有中文注解。
该程序中 使用了一个纹理，用来保存着色器中间数据并再传着色器。

 

这里也用1个纹理来回传中间结果相加，其它7个纹理用于卷积。

生成一个空数据纹理：

//加法纹理
void initadd()
{
	
 
	float * TexData= new float[imgWidth * imgHeight];
	memset(TexData, 0,imgWidth * imgHeight*sizeof(float));//清零

	if(texture == 0)
	{
		//设置输出纹理的参数
		glGenTextures( 1, &texture );
		glBindTexture( GL_TEXTURE_RECTANGLE_ARB, texture );
	 
		glTexParameteri( GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER );
		glTexParameteri( GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER );
	 
		//纹理过滤的方式不应该设置为线性插值
		glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
		glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
	 
		//没有给输出的纹理数据，等待程序进行赋值
		//glTexImage2D( GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, imgWidth, imgHeight, 0,GL_RGBA,GL_FLOAT,0 ); 
		glTexImage2D( GL_TEXTURE_RECTANGLE_ARB, 0, GL_R32F, imgWidth, imgHeight, 0,GL_RED,GL_FLOAT,TexData ); 
		glTexEnvi( GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE );
 
	}
	else
	{
		glBindTexture( GL_TEXTURE_RECTANGLE_ARB, texture );
	 
		glTexImage2D( GL_TEXTURE_RECTANGLE_ARB, 0, GL_R32F, imgWidth, imgHeight, 0,GL_RED,GL_FLOAT,TexData ); 
	}

	delete []TexData;  TexData=NULL; 
}


结果回传：

//结果转到 texture 中
glBindTexture( GL_TEXTURE_RECTANGLE_ARB, texture );
glCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, 0, 0, imgWidth, imgHeight);


着色器：

//卷积着色器 convolution.h
#version 400 compatibility
 
	//层数据 8纹理
     uniform sampler2DRect  Texture0;           
     uniform sampler2DRect  Texture1;           
     uniform sampler2DRect  Texture2;           
     uniform sampler2DRect  Texture3;           
     uniform sampler2DRect  Texture4;           
     uniform sampler2DRect  Texture5;           
     uniform sampler2DRect  Texture6;           
     uniform sampler2DRect  Texture7;           
	//核宽
	 uniform int kw;                                
	//核数量
	 uniform int kNum;                                
	//9x9的核大小 , 5x5则只使用前面部分
	// uniform float kernel[81];                                
	 uniform float kernel[648];                                
	//偏置
	 uniform float bias;   
	//激活
	uniform int active;                     

	 float relu(float i){  
     	if (i > 0.0){  
     		 return i;  
     	} else {  
     		 return 0.0;  
     	} 
	 } 

	 vec4 vec4relu(vec4 v){  
	 	return vec4(relu(v[0]), relu(v[1]), relu(v[2]), relu(v[3]));  
	 } 

	 void main() 
	 { 
	 	vec2 pos = gl_TexCoord[0].st;  //坐标
	 	vec4 fSum = vec4(0.0,0.0,0.0,0.0);  //卷积值
	 	ivec2 vecSize = textureSize(Texture0);  //层数据宽高

	 	int index = 0; 
	 		int coreSize2=kw/2; //半核宽
	 		for (float i = pos.x - coreSize2; i < pos.x + coreSize2 + 1.0; i += 1.0)  //对准核心
	 			for (float j = pos.y - coreSize2; j < pos.y + coreSize2 + 1.0; j += 1.0) 
	 			{ 
	 				if (i >=0 && j >= 0 && i < vecSize.x && j < vecSize.y) //相当于边界以 0 填充
	 				{ 
	 					vec4 currentColor = texture2DRect(Texture0,vec2(i,j));  
	 					fSum += currentColor*kernel[index];   //积和
	 				} 
	 				index++;  //遍历核
	 		} 
	 		if (kNum>1) 
	 		{ 
	 			for (float i = pos.x - coreSize2; i < pos.x + coreSize2 + 1.0; i += 1.0)  //对准核心
	 				for (float j = pos.y - coreSize2; j < pos.y + coreSize2 + 1.0; j += 1.0) 
	 				{ 
	 					if (i >=0 && j >= 0 && i < vecSize.x && j < vecSize.y) //相当于边界以 0 填充
	 					{ 
	 						vec4 currentColor = texture2DRect(Texture1,vec2(i,j));  
	 						fSum += currentColor*kernel[index];   //积和
	 					} 
	 					index++;  //遍历核
	 			} 
	 		} 
	 		if (kNum>2) 
	 		{ 
	 			for (float i = pos.x - coreSize2; i < pos.x + coreSize2 + 1.0; i += 1.0)  //对准核心
	 				for (float j = pos.y - coreSize2; j < pos.y + coreSize2 + 1.0; j += 1.0) 
	 				{ 
	 					if (i >=0 && j >= 0 && i < vecSize.x && j < vecSize.y) //相当于边界以 0 填充
	 					{ 
	 						vec4 currentColor = texture2DRect(Texture2,vec2(i,j));  
	 						fSum += currentColor*kernel[index];   //积和
	 					} 
	 					index++;  //遍历核
	 			} 
	 		} 
	 		if (kNum>3) 
	 		{ 
	 			for (float i = pos.x - coreSize2; i < pos.x + coreSize2 + 1.0; i += 1.0)  //对准核心
	 				for (float j = pos.y - coreSize2; j < pos.y + coreSize2 + 1.0; j += 1.0) 
	 				{ 
	 					if (i >=0 && j >= 0 && i < vecSize.x && j < vecSize.y) //相当于边界以 0 填充
	 					{ 
	 						vec4 currentColor = texture2DRect(Texture3,vec2(i,j));  
	 						fSum += currentColor*kernel[index];   //积和
	 					} 
	 					index++;  //遍历核
	 			} 
	 		} 
	 		if (kNum>4) 
	 		{ 
	 			for (float i = pos.x - coreSize2; i < pos.x + coreSize2 + 1.0; i += 1.0)  //对准核心
	 				for (float j = pos.y - coreSize2; j < pos.y + coreSize2 + 1.0; j += 1.0) 
	 				{ 
	 					if (i >=0 && j >= 0 && i < vecSize.x && j < vecSize.y) //相当于边界以 0 填充
	 					{ 
	 						vec4 currentColor = texture2DRect(Texture4,vec2(i,j));  
	 						fSum += currentColor*kernel[index];   //积和
	 					} 
	 					index++;  //遍历核
	 			} 
	 		} 
	 		if (kNum>5) 
	 		{ 
	 			for (float i = pos.x - coreSize2; i < pos.x + coreSize2 + 1.0; i += 1.0)  //对准核心
	 				for (float j = pos.y - coreSize2; j < pos.y + coreSize2 + 1.0; j += 1.0) 
	 				{ 
	 					if (i >=0 && j >= 0 && i < vecSize.x && j < vecSize.y) //相当于边界以 0 填充
	 					{ 
	 						vec4 currentColor = texture2DRect(Texture5,vec2(i,j));  
	 						fSum += currentColor*kernel[index];   //积和
	 					} 
	 					index++;  //遍历核
	 			} 
	 		} 
	 		if (kNum>6) 
	 		{ 
	 			for (float i = pos.x - coreSize2; i < pos.x + coreSize2 + 1.0; i += 1.0)  //对准核心
	 				for (float j = pos.y - coreSize2; j < pos.y + coreSize2 + 1.0; j += 1.0) 
	 				{ 
	 					if (i >=0 && j >= 0 && i < vecSize.x && j < vecSize.y) //相当于边界以 0 填充
	 					{ 
	 						vec4 currentColor = texture2DRect(Texture6,vec2(i,j));  
	 						fSum += currentColor*kernel[index];   //积和
	 					} 
	 					index++;  //遍历核
	 			} 
	 		} 
	 		if (kNum>7) 
	 		{ 
	 			for (float i = pos.x - coreSize2; i < pos.x + coreSize2 + 1.0; i += 1.0)  //对准核心
	 				for (float j = pos.y - coreSize2; j < pos.y + coreSize2 + 1.0; j += 1.0) 
	 				{ 
	 					if (i >=0 && j >= 0 && i < vecSize.x && j < vecSize.y) //相当于边界以 0 填充
	 					{ 
	 						vec4 currentColor = texture2DRect(Texture7,vec2(i,j));  
	 						fSum += currentColor*kernel[index];   //积和
	 					} 
	 					index++;  //遍历核
	 			} 
	 		} 
	//加法 加上 上次结果
	 		if (kNum==1) 
	 			fSum += texture2DRect(Texture1,vec2(pos.x,pos.y));   
	 		else if (kNum==2) 
	 			fSum += texture2DRect(Texture2,vec2(pos.x,pos.y));   
	 		else if (kNum==3) 
	 			fSum += texture2DRect(Texture3,vec2(pos.x,pos.y));   
	 		else if (kNum==4) 
	 			fSum += texture2DRect(Texture4,vec2(pos.x,pos.y));   
	 		else if (kNum==5) 
	 			fSum += texture2DRect(Texture5,vec2(pos.x,pos.y));   
	 		else if (kNum==6) 
	 			fSum += texture2DRect(Texture6,vec2(pos.x,pos.y));   
	 		else if (kNum==7) 
	 			fSum += texture2DRect(Texture7,vec2(pos.x,pos.y));   

	 	fSum  += bias;  //加偏置
	//激活
		if(active==1)
			fSum = vec4relu(fSum);
	 	gl_FragColor = fSum;  

	 }


层卷积：

//核数据，核宽，输入维度，输出维度，偏置数据，输入数据，输出数据，是否激活
//核大小：kw * kw * 输入维度 * 输出维度。
//输入数据大小：wh * 输入维度。 输出数据大小：wh * 输出维度。
//加法结果在fbo中，中间不用读出，relu也在GLSL中完成
void conv_GLSL_层_add7(float* kernel,int kw,int inNum,int outNum,float *bias,float *inData, float * &outData,bool active=true)
{
//可以不是7个
#define CONV_NUM 7

	//7个纹理用于卷积，1个纹理用于加法
	int p=0;
	int q=0;

	//printf("核宽：%d,输入维度：%d,输出维度：%d\n",kw,inNum,outNum);
	//加载全部输入通道到多纹理
	init(inData,inNum);

	initadd();

	//最大 7个9x9 核
	float kernel648[648]={0.0f};

	clock_t start_t, end_t;//计算时间
	double total_t;
 
	start_t = clock();


	int wh=imgHeight * imgWidth;
	outData=new float[wh*outNum];
	memset(outData, 0, wh*outNum*sizeof(float));//清零

	float * _0Data= new float[imgWidth * imgHeight];
	memset(_0Data, 0,imgWidth * imgHeight*sizeof(float));//清零


	float *out=outData;

	float *in=inData;
	float * kernel_s=kernel;//当前核


	for(int k=0;k<outNum;++k)
	{
		//一次实现7个卷积
		int kNum=(inNum<CONV_NUM)?inNum:CONV_NUM;
		for(int i=0;i<inNum;i+=CONV_NUM)
		{
				
			//最多7核
			if((kNum==CONV_NUM) && (i+CONV_NUM>inNum))//余数
				kNum= inNum % CONV_NUM;
			//if(kNum==CONV_NUM)
			//	printf(".");
			//else
			//	printf("%d ",kNum);

			memcpy(kernel648, kernel_s, kNum*kw*kw*sizeof(float));
			kernel_s+=kw*kw*kNum;

				
		 
			if ( progHandle <= 0 )
				printf("Failed to run shader.\n");
			else{
				char txt[255];
				//传送纹理 Texture0--- Texture7
				for(int j=0;j<kNum;++j)
				{
					sprintf_s(txt,255,"Texture%d\0",j);
					glActiveTexture( GL_TEXTURE0 +j);
					glBindTexture(GL_TEXTURE_RECTANGLE_ARB,textureN[i+j]);
					glUniform1i( glGetUniformLocation( progHandle, txt ),  j);  
					//printf("%s.\n",txt);
				}
					
				//激活 纹理
				sprintf_s(txt,255,"Texture%d\0",kNum);
				glActiveTexture( GL_TEXTURE0 +kNum);
				glBindTexture(GL_TEXTURE_RECTANGLE_ARB,texture);
				glUniform1i( glGetUniformLocation( progHandle, txt ),  kNum);  
				//printf("%s.\n",txt);

				glUniform1i( glGetUniformLocation( progHandle, "kw" ), kw );   //核宽
				glUniform1i( glGetUniformLocation( progHandle, "kNum" ), kNum );   //核1--8个

				//glUniform1fv( glGetUniformLocation( progHandle, "kernel"),81,kernel81);//核数据
				glUniform1fv( glGetUniformLocation( progHandle, "kernel"),kw*kw*kNum,kernel648);//核数据
				//加偏置
				if(i+CONV_NUM>=inNum && bias!=NULL)
				{
					glUniform1f( glGetUniformLocation( progHandle, "bias"),bias[k]);//偏置数据
				}
				else
				{
					glUniform1f( glGetUniformLocation( progHandle, "bias"),0.0f);//无偏置 
				}
			}
		 
			display();
		 
			//readFromTexture( outPutFb );



			//相加
			//for(int j=0;j<wh;++j)
			//{
			//	out[j]+=outPutFb[j];
			//}
			//取出数据
			if(i+kNum==inNum)
			{
				p++;
				readFromTexture( outPutFb );
				memcpy(out,outPutFb,wh*sizeof(float));
				//清0
				glBindTexture( GL_TEXTURE_RECTANGLE_ARB, texture );
				glTexImage2D( GL_TEXTURE_RECTANGLE_ARB, 0, GL_R32F, imgWidth, imgHeight, 0,GL_RED,GL_FLOAT,_0Data ); 
			}
			else
			{
				//结果转到 texture 中
				glBindTexture( GL_TEXTURE_RECTANGLE_ARB, texture );
				//glTexImage2D( GL_TEXTURE_RECTANGLE_ARB, 0, GL_R32F, imgWidth, imgHeight, 0,GL_RED,GL_FLOAT,outPutFb ); 
	            glCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, 0, 0, imgWidth, imgHeight);   

			}

			end_t = clock();
	   
		   total_t = (double)(end_t - start_t) / CLOCKS_PER_SEC;
		   if(total_t>1.0){
				printf("%d/%d\n",k,outNum);
				start_t = clock();
		   }
		}
		out+=wh;
	}

	//if(active)//激活
	//	relu(outData,wh*outNum);
	//清理
	for(int i=0;i<64;++i)
	{
		if(	textureN[i] !=0)
		{
			//删除纹理
			glDeleteTextures(1,textureN+i);
			textureN[i]=0;
		}
	}
		
	delete []_0Data;  _0Data=NULL; 

}

这样有没有快一点呢?

结束

 

juebai123
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GLSL层卷积
juebai123的博客
08-22 353
前面只是完成了一个0至1的进程，谈不上有多快。 先了解下网络卷积层的特性吧，这样才有针对性。
GLSL层卷积（先清理）
juebai123的博客
09-14 163
测试了《GPU编程之GLSL（五）——二维离散卷积》一文的程序，发现先运行哪个“clean.frag”，程序总运行时间更短，就以该文为模板来运行层卷积。 先把《glsl着色器实现多重纹理与帧缓冲对象（fbo）》一文的着色器出错提示部分复制过来（不然，将不能调试着色器）。 接口和前面相同，为了区别加一个G： void conv_initG(int argc, char* argv[],int h,int w) //核数据，核宽，输入维度，输出维度，偏置数据，输入数据，输出数据，是否激活 //核大小：
GLSL层卷积（宽*高*输出通道数）（计算单位数）
juebai123的博客
10-15 444
增加计算单位数，可以加快计算速度。 计算单位 从 iWidth * iHeight 增加到 iWidth * iHeight * outNum： mNumGroupsX = iWidth; int xSize = iHeight; mNumGroupsY = outNum; mNumGroupsZ = 1;//inNum; if (iHeight > 1024) printf("图片高度太大，不支持\n"); else textureParameters.shader_sou
GLSL层卷积（缓存对象）
juebai123的博客
09-21 283
下载了《OpenGL编程指南（第八版）-中文扫描版》以及《OpenGL编程指南 VS2015代码》。 该例子工程包已经设置好了 freeglut，glew 等库，只要安装了vs2015，马上就可以用，非常方便。 在第11课《11.2-01BufferObject》中讲了：着色器可以对“缓存对象”读写。 我们的层卷积中，也用一个“缓存对象”传送卷积核，并回收卷积结果（前半部分结果，后半部分核）。 //核数据，核宽，输入维度，输出维度，偏置数据，输入数据，输出数据，是否激活 //核大小：kw * kw
使用 GLSL 运行网络（GLSL卷积）
juebai123的博客
08-17 748
使用GPU（OpenGL）来运行网络应该会快一点吧。
GLSL_glsl语言学习_GLSL_
10-02
着色器语言学习教程，学习OpenGL的必备技能
GLSL:学习GLSL
03-05
GLSL，全称为OpenGL Shading Language，是一种编程语言，用于为OpenGL图形库编写着色器。它是GPU（图形处理单元）编程的核心工具，允许开发者直接控制图形硬件来实现复杂的渲染效果。GLSL主要用于创建顶点着色器和...
GLSL 中文手册，shader学习
07-18
详细介绍着色器程序中的数据类型的和内置函数，学习GLSL必备，写shader时查阅用
GLSL.zip_GLSL
09-23
GLSL 帮助文件,收集资料整理制作，希望可以给您提供帮助
GLSLangSpec.4.60_GLSL4.6_
10-01
GLSL（OpenGL Shading Language）是一种着色语言，用于为OpenGL图形库编写着色器，以实现复杂的图形渲染效果。GLSL4.6是GLSL的第4.6版本，它在之前的版本基础上进行了更新和优化，以适应现代GPU的功能和性能需求。...
卷积神经网络中间结果可视化
adurey的博客
04-08 976
pytorch默认只保存最后一层的输出，中间层输出默认不保存，要提取中间层网络输出值，需要使用回调函数register_forward_hook()，通过传入处理函数，便可以提取和保存特点网络层的输出值。 class ActivationData(): #网络输出值 outputs = None def __init__(self,layer): #在模型的layer_num层上注册回调函数，并传入处理函数hook_fn self.hook = layer.register_forward_h
OpenGL/GLSL数据传递小记(3.x)(转)
weixin_34234721的博客
07-04 359
OpenGL/GLSL规范在不断演进着，我们渐渐走进可编程管道的时代的同时，崭新的功能接口也让我们有点缭乱的感觉。本文再次从OpenGL和GLSL之间数据的传递这一点，记录和介绍基于OpenGL3.x的新方式，也会适时介绍Unform Buffer Objecct(UBO)这一重要特性。——ZwqXin.com 本文可视为大致一年半前的本博客的[OpenGL/GLSL数据传递小记(2.x)]一文...
opengl3.x之glsl数据传递VAO，VBO
zhouchao_0321的博客
09-14 394
VBO： 显卡存储空间里的一块缓存区(Buffer)，用于记录顶点的信息，包括法线，问路坐标等，这个Buffer有它的名字(VBO的ID)，OpenGL在GPU的某处记录着这个ID和对应的显存地址（或者地址偏移，类似内存）。 VAO：是一个对象，其中包含一个或者更多的Vertex Buffer Objects，用于记录渲染对象的完整信息。 使用步骤如下： 1.生成VAO void glGe...
GPU编程之GLSL（五）——二维离散卷积
Sun7_She的专栏
08-13 3001
本程序共分为7个文件：
OpenGL ES之glUniform函数
热门推荐
飞鱼
07-13 5万+
函数名： glUniform 功能： 为当前程序对象指定Uniform变量的值。（译者注：注意，由于OpenGL ES由C语言编写，但是C语言不支持函数的重载，所以会有很多名字相同后缀不同的函数版本存在。其中函数名中包含数字（1、2、3、4）表示接受这个数字个用于更改uniform变量的值，i表示32位整形，f表示32位浮点型，ub表示8位无符号byte，ui表示32位无符号整形
OpenGL 实现大眼和瘦脸
翻肚鱼儿的博客
04-10 442
opengl
指针专题
maskpass的博客
10-07 229
指针和指针变量： 指针就是地址，地址就是指针。 地址就是内存单元的编号。 指针变量是存放地址的变量。 指针和指针变量是两个不同的概念。 但是要注意：通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样。 ...
想知道深度学习卷积在GPU上如何优化吗？“大神”赵开勇带你深入浅出
凌风探梅的专栏
08-22 2566
想知道深度学习卷积在GPU上如何优化吗？“大神”赵开勇带你深入浅出 2016-08-19 11:54 转载 陈杨英杰 0条评论 雷锋网(搜索“雷锋网”公众号关注)按： 本文转载自英伟达NVIDIA企业解决方案公众号。赵开勇，香港浸会大学计算机系异构计算实验室PhD Candidate，长期从事高性能计算领域研究，在CPU、GPU异构计算方面有多年的研究经验。赵开勇
学习ShaderToy第一天： glsl语言内置函数gl_FragCoord
jinghouxiang的专栏
02-26 1万+
运行环境：Android opengl es版本： 2.0 3D引擎库 ： Rajawali3D ShaderToy上用的shader语言 为glsl ， 效果是用webgl跑的，而webgl封装了opengl es，  所以ShaderToy上的例子同样使用于Android端。 ShaderToy基本上 都是用fragment shader 对栅格化后的像素进行处
glsl
最新发布
05-31
GLSL（OpenGL Shading Language）是一种用于编写OpenGL程序的编程语言，它是一种基于C语言的高级着色器语言，用于编写GPU上的着色器程序。GLSL主要用于OpenGL、OpenGL ES和WebGL等图形库中，通过编写着色器程序来实现各种图形效果，如光照、阴影、反射等。 GLSL支持多种数据类型，包括标量（float）、向量（vec2、vec3、vec4）、矩阵（mat2、mat3、mat4）和纹理（sampler2D、samplerCube）等。GLSL还提供了许多内置函数，如向量运算、矩阵运算、数学运算、纹理采样等，以及流程控制语句，如if、for、while等。 GLSL中的着色器程序包括顶点着色器、片元着色器和几何着色器等，其中顶点着色器主要用于处理顶点数据，片元着色器主要用于处理像素数据，几何着色器主要用于处理几何图形数据。通过编写GLSL着色器程序，可以实现各种图像效果，如模糊、反锯齿、色彩调整、光照计算等。 以下是一个简单的GLSL片元着色器程序示例，用于将颜色值反转： ```glsl #version 330 core in vec2 TexCoord; out vec4 FragColor; uniform sampler2D texture1; void main() { vec4 color = texture(texture1, TexCoord); color.rgb = 1.0 - color.rgb; FragColor = color; } ``` 在上面的代码中，`in`表示输入变量，`out`表示输出变量，`uniform`表示全局变量，`sampler2D`表示二维纹理变量。`main()`函数是GLSL程序的主函数，用于处理每个像素的颜色。`texture()`函数用于从纹理中获取颜色值，`1.0 - color.rgb`表示将颜色值反转。`FragColor`是输出变量，表示当前像素的颜色值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值