Hexo

void Init()
{
	//注意颜色纹理的参数设置GL_RGB32F、GL_RGB
    glGenTextures(1, &pickingTexture);
	glBindTexture(GL_TEXTURE_2D, pickingTexture);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, 1024, 1024,0, GL_RGB, GL_FLOAT, NULL);
    //将此纹理附加到FBO的GL_COLOR_ATTACHMENT0目标，这将使其成为片段着色器输出的目标。
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,pickingTexture, 0);

	glDrawBuffer(GL_COLOR_ATTACHMENT0);
	glBindTexture(GL_TEXTURE_2D, 0);
    //重置读取缓冲区和帧缓冲区
    glReadBuffer(GL_NONE);
	glBindFramebuffer(GL_FRAMEBUFFER, 0);

}

#version 330
uniform uint gDrawIndex;
uniform uint gObjectIndex;
out vec3 FragColor;
void main()
{
  FragColor = vec3(float(gObjectIndex), float(gDrawIndex),float(gl_PrimitiveID + 1));
}

glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
/*绘制图形*/
glBindFramebuffer(GL_FRAMEBUFFER, 0);

struct PixelInfo {
	float ObjectID;float DrawID;float PrimID;
	PixelInfo() {ObjectID = 0.0f;DrawID = 0.0f;PrimID = 0.0f;}};
PixelInfo ReadPixel(unsigned int x, unsigned int y)
{
	glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
	glReadBuffer(GL_COLOR_ATTACHMENT0);
	PixelInfo Pixel;
	glReadPixels(x, y, 1, 1, GL_RGB, GL_FLOAT, &Pixel);
    //必须重置读取缓冲区和帧缓冲区
	glReadBuffer(GL_NONE);
	glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
	return Pixel;
}

glUniform1ui(gObjectIndexID, 0);
glUniform1ui(gDrawIndexID, 1);

    glfwGetCursorPos(window,&x,&y);
PixelInfo Pixel = ReadPixel(int(x), 768-int(y)+1);
if (Pixel.PrimID != 0) {
	glm::uint a = (uint)Pixel.DrawID;
	glm::uint b = (uint)Pixel.PrimID;
	if (a == 0) {
		if(b == 1){glColor4f(0.4f, 0.0f, 0.0f, 1.0f);}
		if (b == 2) {glColor4f(0.4f, 0.4f, 0.0f, 1.0f);}
	}
	else if (a == 1) {
		if (b == 1) {glColor4f(0.0f, 0.0f, 0.4f, 1.0f);}
		if (b == 2) {glColor4f(0.4f, 0.4f, 0.4f, 1.0f);}
	}
}
else {
	glColor4f(0.0f, 0.4f, 0.0f, 1.0f);
}

//创建存储了3个MPV矩阵的顶点属性数组，glm::mat4类型
static glm::mat4 WVPMats[] = {MVP1,MVP2,MVP3};
//创建并绑定缓冲区
GLuint MVPbuffer;
glGenBuffers(1, &MVPbuffer);
glBindBuffer(GL_ARRAY_BUFFER, MVPbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::mat4)* 3, WVPMats, GL_DYNAMIC_DRAW);

for (unsigned int i = 0; i < 4; i++) {
	glEnableVertexAttribArray(1 + i);
	glVertexAttribPointer(1 + i, 4, GL_FLOAT, GL_FALSE, sizeof(glm::mat4),
		(const GLvoid*)(sizeof(GLfloat) * i * 4));
	glVertexAttribDivisor(1 + i, 1);
}

glDrawArraysInstanced(GL_TRIANGLES, 0, 36, 3);

#version 330
layout (location = 0) in vec3 Position;
layout (location = 1) in mat4 MVP;
void main()
{
    gl_Position = MVP * vec4(Position, 1.0);
};

vec3 vertexTangent_cameraspace = MV3x3 * vertexTangent_modelspace;
vec3 vertexBitangent_cameraspace = MV3x3 * vertexBitangent_modelspace;
vec3 vertexNormal_cameraspace = MV3x3 * vertexNormal_modelspace;

mat3 TBN = transpose(mat3(
	vertexTangent_cameraspace,
	vertexBitangent_cameraspace,
	vertexNormal_cameraspace ));

LightDirection_tangentspace = TBN * LightDirection_cameraspace;
EyeDirection_tangentspace =  TBN * EyeDirection_cameraspace;

glGenTextures(1, &depthTexture);
glBindTexture(GL_TEXTURE_2D, depthTexture);
//GL_DEPTH_COMPONENT：每个纹素放一个单精度浮点数用于存放已经标准化后的深度值 0：暂时不提供数据
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16, 1024, 1024, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
//过滤
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);

glGenFramebuffers(1, &FramebufferName);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
//GL_DEPTH_ATTACHMENT:附着在上面的纹理收到深度测试的结果,0：一个层级
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthTexture, 0);

glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
GLuint error = glCheckFramebufferStatus(GL_FRAMEBUFFER);
	if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
		return false;

//将图像绘制进帧缓冲而不是显示在屏幕
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
//从光源的角度观察，计算mvp
glm::vec3 lightInvDir = glm::vec3(0.5f, 2, -2);
glm::vec3 lightPos(5, 20, 20);
glm::mat4 depthP = glm::perspective<float>(45.0f, 1.0f, 2.0f, 50.0f);
glm::mat4 depthV = glm::lookAt(lightPos, lightPos-lightInvDir, glm::vec3(0,1,0));
glm::mat4 depthM = glm::mat4(1.0);
glm::mat4 depthMVP = depthP * depthV * depthM;
//正常绘制图像
//回到默认帧缓冲，渲染到屏幕
glBindFramebuffer(GL_FRAMEBUFFER, 0);

//将帧缓冲纹理作为正常纹理渲染
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, depthTexture);
glUniform1i(TextureID, 0);
//便于从齐次坐标[-1,1]变换到纹理坐标[0,1]
glm::mat4 biasMatrix(
             0.5, 0.0, 0.0, 0.0,
			0.0, 0.5, 0.0, 0.0,
			0.0, 0.0, 0.5, 0.0,
			0.5, 0.5, 0.5, 1.0);
//除了传入相机视角的MVP矩阵，还要传入光源视角的MVP矩阵
glm::mat4 depthBiasMVP = biasMatrix * depthMVP;

ShadowCoord = DepthBiasMVP * vec4(position,1);//光源视角
gl_Position =  MVP * vec4(position,1);//相机视角

gl_FragColor.rgb = 
	 MaterialAmbientColor +
	 visibility* MaterialDiffuseColor * LightColor * LightPower * cosTheta / (distance*distance) +
	 visibility*MaterialSpecularColor * LightColor * LightPower * pow(cosAlpha,5) / (distance*distance);

static GLuint
InitTextures(void)
{
    GLenum imgFormat;
    GLuint texture;
	glGenTextures(1, &texture);
	glBindTexture(GL_TEXTURE_CUBE_MAP, texture);

	GLint imgWidth, imgHeight;
	GLubyte* image = NULL;

	image = LoadRGBImage(TexFiles[0], &imgWidth, &imgHeight, &imgFormat);

	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0,
        GL_RGB, imgWidth, imgHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0,
		GL_RGB, imgWidth, imgHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0,
		GL_RGB, imgWidth, imgHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0,
		GL_RGB, imgWidth, imgHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0,
		GL_RGB, imgWidth, imgHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0,
		GL_RGB, imgWidth, imgHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
	free(image);

	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	glBindTexture(GL_TEXTURE_CUBE_MAP, 0);

	return texture;
}

v_Position=vertexPosition_modelspace;
gl_Position =  MVP * vec4(vertexPosition_modelspace,1);
gl_Position=gl_Position.xyww;

uniform samplerCube myTextureSampler;
gl_FragColor=textureCube(myTextureSampler, v_Position);

glEnable(GL_CULL_FACE);//开启表面剔除(默认背面剔除)
glCullFace(GL_FRONT);//剔除正面实现

glDepthFunc(GL_LEQUAL);

glm::mat4 V = glm::mat4(glm::mat3(getViewMatrix()));//天空盒v矩阵
glm::mat4 V1 = getViewMatrix();//其他物体v矩阵

glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, Texture);
glUniform1i(TextureID, 0);

attribute vec3 vertexPosition_modelspace;
attribute vec2 vertexUV;
attribute vec3 vertexNormal_modelspace;//法线数组

varying vec2 UV;
varying vec3 Position_worldspace;
varying vec3 Normal_cameraspace;
varying vec3 EyeDirection_cameraspace;
varying vec3 LightDirection_cameraspace;

uniform mat4 MVP;
uniform mat4 V;
uniform mat4 M;
uniform vec3 LightPosition_worldspace;

void main(){

	gl_Position =  MVP * vec4(vertexPosition_modelspace,1);
    
	//计算世界空间下的物体矩阵（便于等下计算世界空间下光与表面的距离）
	Position_worldspace = (M * vec4(vertexPosition_modelspace,1)).xyz;
	
    //计算观察空间下的物体矩阵
	vec3 vertexPosition_cameraspace = ( V * M * vec4(vertexPosition_modelspace,1)).xyz;
    
	EyeDirection_cameraspace = vec3(0,0,0) - vertexPosition_cameraspace;
    
    //观察空间下光的位置
	vec3 LightPosition_cameraspace = ( V * vec4(LightPosition_worldspace,1)).xyz;
	
    //观察空间下表面到点光源的向量
    //如果是基于平行光的漫反射此处直接归一化光的方向
    LightDirection_cameraspace = LightPosition_cameraspace + EyeDirection_cameraspace;
	
    //计算观察空间下的法线数组
	Normal_cameraspace = ( V * M * vec4(vertexNormal_modelspace,0)).xyz; 

	UV = vertexUV;
}

#version 120

varying vec2 UV;
varying vec3 Position_worldspace;
varying vec3 Normal_cameraspace;
varying vec3 EyeDirection_cameraspace;
varying vec3 LightDirection_cameraspace;

uniform sampler2D myTextureSampler;
uniform mat4 MV;
uniform vec3 LightPosition_worldspace;

void main(){
    
    //光照颜色和强度
	vec3 LightColor = vec3(1,1,1);
	float LightPower = 50.0f;
	
	//材质本身的颜色也影响最终颜色
    //漫反射分量
	vec3 MaterialDiffuseColor = texture2D( myTextureSampler, UV ).rgb;
    //环境光分量
	vec3 MaterialAmbientColor = vec3(0.1,0.1,0.1) * MaterialDiffuseColor;
    //镜面光分量
	vec3 MaterialSpecularColor = vec3(0.3,0.3,0.3);

	//计算光与表面的距离：光通量与距离的平方成反比（世界空间下）
	float distance = length( LightPosition_worldspace - Position_worldspace );

	//归一化n和l（观察空间下计算（可以是任意空间））
	vec3 n = normalize( Normal_cameraspace );
	vec3 l = normalize( LightDirection_cameraspace );

    //n：表面法线，l表面到光源的单位向量（与光相反，简化计算），二者计算点积
    //如果光源在三角形后面，n和l方向相反，那么n.l是负值。这意味着colour将是一个负值，没有意义。因此这种情况下必须用clamp()将cosTheta截取为0：
	float cosTheta = clamp( dot( n,l ), 0,1 );
	
	//E：观察者，R反射光，二者计算点积
	vec3 E = normalize(EyeDirection_cameraspace);
	vec3 R = reflect(-l,n);//内置函数计算反射光
	float cosAlpha = clamp( dot( E,R ), 0,1 );
	
    //最终颜色计算
    //聚光灯需要添加余弦参数
	gl_FragColor.rgb = 
		MaterialAmbientColor +
		MaterialDiffuseColor * LightColor * LightPower * cosTheta / (distance*distance) +
        //pow(cosAlpha,5)用来控制镜面反射的波瓣，镜面反射与材料本身有关
		MaterialSpecularColor * LightColor * LightPower * pow(cosAlpha,5) / (distance*distance);
}

glm::mat4 Rotation_tree2 = eulerAngleYXZ(gOrientation1.y, gOrientation1.x, gOrientation2.z);
glm::mat4 Transla_tree2 = translate(mat4(), gPosition2);
glm::mat4 Scaling_tree2 = scale(mat4(), vec3(0.3f, 0.3f, 0.3f));
glm::mat4 Model_tree2 = Transla_tree2 * Rotation_tree2 * Scaling_tree2;

glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture2);

glUniform1i(Texture1ID, 0);
glUniform1i(Texture2ID, 1);

float cube1[4] = { 1.0, -1.0,1.0,0.8};
float cube2[4] = { 0.7, 0.8,1.0,0.1};
float cube3[4] = { -1.0, 0.5, 1.0,0.3};
float cube4[4] = { 0.4, 0.8,1.0,0.6};

static const GLfloat tex_data[] = {
        0.0f,1.0f,
        1.0f,1.0f,
        1.0f,0.0f,
        0.0f,0.0f
 };

  UV = vertexUV;
  if (position.x<=-0.2) {
    UV.x = UV.x /2.0;UV.y = UV.y /2.0-0.001;
  }else{
      if (position.x<0.1){
   UV.x = UV.x /2.0+0.5; UV.y = UV.y /2.0;
}else{
   if (position.x<0.4){
       UV.x = UV.x /2.0;UV.y = UV.y /2.0+0.5;
   }else{
          UV.x = UV.x /2.0+0.5;UV.y = UV.y /2.0+0.5; }}}

float y=texture2D(sampler, UV).a;
if(position.y>0.0){
  gl_Position = vec4(position.x,y,position.z,1);
}else{
gl_Position = vec4(position,1);}

float color=texture2D( sampler, UV ).a;
vec3 MaterialDiffuseColor=vec3(color,0.0,0.0);
vec3 normal = texture2D( sampler, UV ).rgb;
vec3 Normal_cameraspace = ( V * M * vec4(normal,0)).xyz;

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,  GL_MIRRORED_REPEAT); 
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,  GL_MIRRORED_REPEAT);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

//gluBuild2DMipmaps(GL_TEXTURE_2D, 4, imgWidth, imgHeight,imgFormat, GL_UNSIGNED_BYTE, image);
//用载入的图片生成纹理
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imgWidth, imgHeight, 0, imgFormat, GL_UNSIGNED_BYTE, image);
//创建多级纹理
glGenerateMipmap(GL_TEXTURE_2D);
//释放图像内存
free(image);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

const GLchar* feedbackVaryings[] = { "outposition","fragcolor"};
glTransformFeedbackVaryings(ProgramID, 2, feedbackVaryings, GL_SEPARATE_ATTRIBS);

glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, databufferb);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, databuffera);

glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, databufferb);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, databuffera);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1, colorbufferb);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1, colorbuffera);

in vec4 inposition;
in vec4 color;
out vec4 outposition;
out vec4 fragcolor;//与feedbackVaryings[]同名
/*在main函数中对inposition和color进行变换*/
gl_Position=MVP * inposition;

//tf缓冲区只用创建一个
GLuint tfbuffera;
glGenTransformFeedbacks(1, &tfbuffera);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfbuffera);
//给tf缓冲绑定相应的缓冲对象（databuffer用GL_ARRAY_BUFFER类型创建）
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, databufferb);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, databuffera);

glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(data), nullptr, GL_DYNAMIC_DRAW);

//绑定
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfbuffera);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, databuffer[flag]);//将变换后数据写入databufferb
glEnable(GL_RASTERIZER_DISCARD);//此次绘制写入tf缓冲因此不进行绘制，禁用光栅化
glBeginTransformFeedback(GL_TRIANGLES);//开启tf缓冲，设置绘制模式与draw相同
//用databuffera也就是最初的数据传入顶点着色器，数据进行第一次变换，但此时不显示，而是写入tf缓冲的databufferb
glEnableVertexAttribArray(positionID);
glBindBuffer(GL_ARRAY_BUFFER, databuffer[!flag]);
glVertexAttribPointer(positionID,4,GL_FLOAT,GL_FALSE,32,(void*)0);
glVertexAttribPointer(colorID,4,GL_FLOAT,GL_FALSE,32,(void*)16);
glDrawArrays(GL_TRIANGLES, 0, 36);
//结束转换反馈模式
glEndTransformFeedback();
//使用光栅化，绘制图形
glDisable(GL_RASTERIZER_DISCARD);
//使用databufferb第一次变换的数据绘制图形，因为此使没开启tf缓冲，因此顶点顶点着色器的数据变换不写入缓冲
glBindBuffer(GL_ARRAY_BUFFER, databuffer[flag]);
glVertexAttribPointer(positionID,4,GL_FLOAT,GL_FALSE,32,(void*)0);
glVertexAttribPointer(colorID,4,GL_FLOAT,GL_FALSE,32,(void*)16);
glDrawArrays(GL_TRIANGLES, 0, 36);
flag = !flag;//进行第二次循环

glVertexAttribPointer(positionID,4,GL_FLOAT,GL_FALSE,32,(void*)0);
glVertexAttribPointer(colorID,4,GL_FLOAT,GL_FALSE,32,(void*)16);