LearnOpenGL 光照—光照贴图—练习（放射光贴图）

最新推荐文章于 2023-06-11 11:10:15 发布
最新推荐文章于 2023-06-11 11:10:15 发布
阅读量916 收藏 4
点赞数 1
分类专栏： OpenGL 图形学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiji333/article/details/115152575
版权

文章目录

初始代码

l i g h t   s h a d e r : light\ shader: light shader:

#version 330 core
layout (location = 0) in vec3 aPos;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
	gl_Position = projection * view * model * vec4(aPos,1.0);
}


#version 330 core
out vec4 FragColor;

void main()
{
	FragColor = vec4(1.0);  将向量的四个分量全部设置为1.0
}

o b j e c t   s h a d e r ： object\ shader： object shader：

#version 330 core
layout (location = 0) in vec3 aPos;   // 位置变量的属性位置值为 0 
layout (location = 1) in vec3 aNormal;
layout (location = 2) in vec2 aTexCoords;

uniform mat4 model;	//模型
uniform mat4 view;	//观察
uniform mat4 projection;	//投影

out vec3 Normal;
out vec3 FragPos;
out vec2 TexCoords;

void main()
{
	// 注意乘法要从右向左读
    gl_Position = projection * view * model * vec4(aPos, 1.0);
    Normal = mat3(transpose(inverse(model))) * aNormal;
    FragPos = vec3(model * vec4(aPos, 1.0));
    TexCoords = aTexCoords;
}


#version 330 core

struct Material
{
	sampler2D diffuse;
	sampler2D specular;
	float shininess;
};

struct Light
{
	vec3 position;
	vec3 ambient;
	vec3 diffuse;
	vec3 specular;
};

in vec3 Normal;
in vec3 FragPos;
in vec2 TexCoords;

out vec4 FragColor;  

uniform Material material;
uniform Light light;
uniform vec3 viewPos;

void main()
{
	//环境光
	vec3 ambient = light.ambient * vec3(texture(material.diffuse,TexCoords));
	//漫反射
	vec3 norm = normalize(Normal);
	vec3 lightDir = normalize(light.position - FragPos);
	float diff = max(dot(norm,lightDir),0.0);
	vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse,TexCoords));
	//镜面反射
	vec3 viewDir = normalize(viewPos - FragPos);
	vec3 reflectDir = reflect(-lightDir,norm);
	float spec = pow(max(dot(reflectDir,viewDir),0.0),material.shininess);
	vec3 specular = light.specular * spec * vec3(texture(material.specular,TexCoords));
	//最终结果
	vec3 result = ambient + diffuse + specular;
	FragColor = vec4(result,1.0);
}

c p p ： cpp： cpp：

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <iostream>
#include "shader.h"
#include "stb_image.h"
#include "camera.h"
#include "texture.h"
using std::cout;

//窗口回调函数
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
	//绘图视口 3D坐标到2D坐标的转换(映射)和这些参数(宽高)有关
	glViewport(0, 0, width, height);
}

//键盘回调
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode);

//鼠标回调
void mouse_callback(GLFWwindow* window, double xpos, double ypos);

//滚轮回调
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);

//窗口初始大小
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

//物体着色器
const char* vShaderPath = "ShaderFiles/shader.vert";
const char* fShaderPath = "ShaderFiles/shader.frag";
//光源着色器
const char* lightvShaderPath = "ShaderFiles/light_shader.vert";
const char* lightfShaderPath = "ShaderFiles/light_shader.frag";

//混合颜色的插值
float mixValue = 0.2f;
//记录鼠标坐标
float lastX, lastY;
bool firstMouse = true;

//摄像机
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));

//光源位置
glm::vec3 lightPos(1.2f, 1.0f, 2.0f);

int main()
{
	//glfw初始化
	glfwInit();
	//告诉glfw我们所使用的opengl版本 此处为3.3
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	//创建窗口
	GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
	if (window == NULL)
	{
		cout << "Failed to create GLFW window\n";
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);
	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
	//设置窗口回调函数
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
	//键盘回调函数
	glfwSetKeyCallback(window, key_callback);
	//鼠标回调
	glfwSetCursorPosCallback(window, mouse_callback);
	//滚轮回调
	glfwSetScrollCallback(window, scroll_callback);

	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		cout << "Failed to initialize GLAD\n";
		return -1;
	}

	//开启深度测试
	glEnable(GL_DEPTH_TEST);

	//着色器对象
	Shader shaderProgram = Shader(vShaderPath, fShaderPath);
	Shader lightShaderProgram = Shader(lightvShaderPath, lightfShaderPath);

	float vertices[] = {
		// positions          // normals           // texture coords
		-0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 0.0f,
		 0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 0.0f,
		 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 1.0f,
		 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 1.0f,
		-0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 1.0f,
		-0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 0.0f,

		-0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 0.0f,
		 0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 0.0f,
		 0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 1.0f,
		 0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 1.0f,
		-0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 1.0f,
		-0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 0.0f,

		-0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
		-0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 1.0f,
		-0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
		-0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
		-0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 0.0f,
		-0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 0.0f,

		 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
		 0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f,
		 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
		 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
		 0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  0.0f, 0.0f,
		 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f,

		-0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f, 1.0f,
		 0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  1.0f, 1.0f,
		 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f, 0.0f,
		 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f, 0.0f,
		-0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  0.0f, 0.0f,
		-0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f, 1.0f,

		-0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f, 1.0f,
		 0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  1.0f, 1.0f,
		 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f, 0.0f,
		 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f, 0.0f,
		-0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  0.0f, 0.0f,
		-0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f, 1.0f
	};

	//顶点缓冲对象 VBO
	//顶点数组对象 VAO
	unsigned int VBO, VAO;
	//渲染物体
	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);

	glBindVertexArray(VAO);

	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	//设置顶点属性
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);

	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
	glEnableVertexAttribArray(1);

	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
	glEnableVertexAttribArray(2);

	//光源
	unsigned int lightVAO;
	glGenVertexArrays(1, &lightVAO);
	glBindVertexArray(lightVAO);

	glBindBuffer(GL_ARRAY_BUFFER, VBO);

	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);

	//漫反射贴图
	Texture diffuseTexture("diffuseTexture", "Images/container2_diffuse.png");

	//镜面光贴图
	//Texture specularTexture("specuTexture", "Images/container2_specular.png");
	Texture specularTexture("specuTexture", "Images/lighting_maps_specular_color.png");

	//线框模式
	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

	//这些uniform不会更新 可以放到循环外面
	shaderProgram.use();
	shaderProgram.setInt("material.diffuse", diffuseTexture.getTextureUnitID());
	shaderProgram.setInt("material.specular", specularTexture.getTextureUnitID());
	shaderProgram.setFloat("material.shininess", 64.0f);
	shaderProgram.setVec3("light.ambient", 0.2f, 0.2f, 0.2f);
	shaderProgram.setVec3("light.diffuse", 0.5f, 0.5f, 0.5f);
	shaderProgram.setVec3("light.specular", 1.0f, 1.0f, 1.0f);
	shaderProgram.setVec3("light.position", lightPos);

	while (!glfwWindowShouldClose(window))
	{
		glClearColor(0.1f, 0.1f, 0.1f, 0.1f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		//矩阵运算
		glm::mat4 lightModel(1.0f);
		glm::mat4 view = camera.GetViewMatrix();
		glm::mat4 projection = glm::perspective(glm::radians(camera.Fov), SCR_WIDTH * 1.0f / SCR_HEIGHT, 0.1f, 100.0f);
		//激活着色器
		shaderProgram.use();
		shaderProgram.setVec3("viewPos", camera.Position);
		shaderProgram.setMat4("model", lightModel);
		shaderProgram.setMat4("view", view);
		shaderProgram.setMat4("projection", projection);
		//贴图
		diffuseTexture.use();
		specularTexture.use();

		glBindVertexArray(VAO);
		glDrawArrays(GL_TRIANGLES, 0, 36);
		//光源着色器
		lightShaderProgram.use();
		lightModel = glm::translate(lightModel, lightPos);
		lightModel = glm::scale(lightModel, glm::vec3(0.2f));
		lightShaderProgram.setMat4("model", lightModel);
		lightShaderProgram.setMat4("view", view);
		lightShaderProgram.setMat4("projection", projection);
		glBindVertexArray(lightVAO);
		glDrawArrays(GL_TRIANGLES, 0, 36);

		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	//这一步是可选的
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	//glDeleteBuffers(1, &EBO);

	//释放资源
	glfwTerminate();
	return 0;
}

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
	if (action == GLFW_REPEAT || action == GLFW_PRESS)
	{
		if (key == GLFW_KEY_ESCAPE)
		{
			glfwSetWindowShouldClose(window, GL_TRUE);
			return;
		}
		switch (key)
		{
		case GLFW_KEY_UP:
			mixValue += 0.1f;
			if (mixValue >= 1.0f)
				mixValue = 1.0f;
			break;
		case GLFW_KEY_DOWN:
			mixValue -= 0.1f;
			if (mixValue <= 0.0f)
				mixValue = 0.0f;
			break;
		case GLFW_KEY_W:
			camera.ProcessKeyboard(FORWARD);
			break;
		case GLFW_KEY_S:
			camera.ProcessKeyboard(BACKWARD);
			break;
		case GLFW_KEY_A:
			camera.ProcessKeyboard(LEFT);
			break;
		case GLFW_KEY_D:
			camera.ProcessKeyboard(RIGHT);
			break;
		default:
			break;
		}
	}
}

void mouse_callback(GLFWwindow* window, double xpos, double ypos)
{
	if (firstMouse)
	{
		firstMouse = false;
		lastX = xpos, lastY = ypos;
	}
	camera.ProcessMouseMovement(xpos - lastX, lastY - ypos);
	lastX = xpos;
	lastY = ypos;
}

void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
	camera.ProcessMouseScroll(yoffset);
}

注：若要查看封装的类的代码，请看我的其他博客。

练习一

调整光源的环境光、漫反射和镜面光向量，看看它们如何影响箱子的视觉输出。

shaderProgram.setVec3("light.ambient", 0.2f, 0.2f, 0.2f);
shaderProgram.setVec3("light.diffuse", 0.5f, 0.5f, 0.5f);
shaderProgram.setVec3("light.specular", 1.0f, 1.0f, 1.0f);

增大环境光。

shaderProgram.setVec3("light.ambient", 1.0f, 1.0f, 1.0f);
shaderProgram.setVec3("light.diffuse", 0.5f, 0.5f, 0.5f);
shaderProgram.setVec3("light.specular", 1.0f, 1.0f, 1.0f);

在这里插入图片描述

增大漫反射光。

shaderProgram.setVec3("light.ambient", 0.2f, 0.2f, 0.2f);
shaderProgram.setVec3("light.diffuse", 1.0f, 1.0f, 1.0f);
shaderProgram.setVec3("light.specular", 1.0f, 1.0f, 1.0f);

在这里插入图片描述

增大镜面反射光。

shaderProgram.setVec3("light.ambient", 0.2f, 0.2f, 0.2f);
shaderProgram.setVec3("light.diffuse", 0.5f, 0.5f, 0.5f);
shaderProgram.setVec3("light.specular", 3.0f, 3.0f, 3.0f);

在这里插入图片描述

练习二

尝试在片段着色器中反转镜面光贴图的颜色值，让木头显示镜面高光而钢制边缘不反光（由于钢制边缘中有一些裂缝，边缘仍会显示一些镜面高光，虽然强度会小很多）。

修改object的片段着色器即可：

#version 330 core

struct Material
{
	sampler2D diffuse;
	sampler2D specular;
	float shininess;
};

struct Light
{
	vec3 position;
	vec3 ambient;
	vec3 diffuse;
	vec3 specular;
};

in vec3 Normal;
in vec3 FragPos;
in vec2 TexCoords;

out vec4 FragColor;  

uniform Material material;
uniform Light light;
uniform vec3 viewPos;

void main()
{
	//环境光
	vec3 ambient = light.ambient * vec3(texture(material.diffuse,TexCoords));
	//漫反射
	vec3 norm = normalize(Normal);
	vec3 lightDir = normalize(light.position - FragPos);
	float diff = max(dot(norm,lightDir),0.0);
	vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse,TexCoords));
	//镜面反射
	vec3 viewDir = normalize(viewPos - FragPos);
	vec3 reflectDir = reflect(-lightDir,norm);
	float spec = pow(max(dot(reflectDir,viewDir),0.0),material.shininess);
	//vec3 specular = light.specular * spec * vec3(texture(material.specular,TexCoords));
	vec3 specular = light.specular * spec * (vec3(1.0) - vec3(texture(material.specular,TexCoords)));
	//最终结果
	vec3 result = ambient + diffuse + specular;
	FragColor = vec4(result,1.0);
}

在这里插入图片描述

练习三

使用漫反射贴图创建一个彩色而不是黑白的镜面光贴图，看看结果看起来并不是那么真实了。如果你不会生成的话，可以使用这张彩色的镜面光贴图。

//镜面光贴图
//Texture specularTexture("specuTexture", "Images/container2_specular.png");
Texture specularTexture("specuTexture", "Images/lighting_maps_specular_color.png");

在这里插入图片描述
在这里插入图片描述

练习四

添加一个叫做放射光贴图(Emission Map)的东西，它是一个储存了每个片段的发光值(Emission Value)的贴图。发光值是一个包含（假设）光源的物体发光(Emit)时可能显现的颜色，这样的话物体就能够忽略光照条件进行发光(Glow)。游戏中某个物体在发光的时候，你通常看到的就是放射光贴图（比如 机器人的眼，或是箱子上的灯带）。将这个纹理（作者为 creativesam）作为放射光贴图添加到箱子上，产生这些字母都在发光的效果。
在这里插入图片描述
在这里插入图片描述
首先修改object的片段着色器：

#version 330 core

struct Material
{
	sampler2D diffuse;
	sampler2D specular;
	float shininess;
};

struct Light
{
	vec3 position;
	vec3 ambient;
	vec3 diffuse;
	vec3 specular;
};

in vec3 Normal;
in vec3 FragPos;
in vec2 TexCoords;

out vec4 FragColor;  

uniform Material material;
uniform Light light;
uniform vec3 viewPos;
uniform sampler2D EmissionMap;

void main()
{
	//环境光
	vec3 ambient = light.ambient * vec3(texture(material.diffuse,TexCoords));
	//漫反射
	vec3 norm = normalize(Normal);
	vec3 lightDir = normalize(light.position - FragPos);
	float diff = max(dot(norm,lightDir),0.0);
	vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse,TexCoords));
	//镜面反射
	vec3 viewDir = normalize(viewPos - FragPos);
	vec3 reflectDir = reflect(-lightDir,norm);
	float spec = pow(max(dot(reflectDir,viewDir),0.0),material.shininess);
	vec3 specular = light.specular * spec * vec3(texture(material.specular,TexCoords));
	//放射光
	vec3 emission = texture(EmissionMap,TexCoords).xyz;
	//最终结果
	vec3 result = ambient + diffuse + specular + emission;
	FragColor = vec4(result,1.0);
}

然后在main.cpp中修改以下几处代码：

//放射光贴图
Texture emissionTexture("emissionTexture", "Images/emission_map.jpg");
……
shaderProgram.setInt("EmissionMap", emissionTexture.getTextureUnitID());
……
emissionTexture.use();

其实就是多了一个放射光嘛。

在这里插入图片描述

csu_xiji
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
OpenGL 光照贴图OpenGL 光照贴图OpenGL 光照贴图
06-11
光照贴图
OpenGL光照2：材质和光照贴图
weixin_30569001的博客
08-16 322
本文是个人学习记录，学习建议看教程 https://learnopengl-cn.github.io/ 非常感谢原作者JoeyDeVries和多为中文翻译者提供的优质教程 的内容为插入注释，可以先跳过 材质 在现实世界里，每个物体会对光产生不同的反应，钢看起来通常会比陶瓷花瓶更闪闪发光，木头箱子也不会像钢制箱子那样对光产生很强的反射 每个物体对镜面高光也有不同的反应，有些物体反射光的...
光照贴图
linuxheik的专栏
10-17 1655
光照贴图 原文 Lighting maps 作者 JoeyDeVries 翻译 Meow J 校对 暂未校对 在上一节中，我们讨论了让每个物体都拥有自己独特的材质从而对光照做出不同的反应的方法。这样子能够很容易在一个光照的场景中给每个物体一个独特的外观，但是这仍不能对一个物体的视觉输出提供
LearnOpengl_光照贴图
qq_40742335的博客
08-26 141
漫反射贴图 DiffuseMap 镜面光贴图 SpecularMap 放射光贴图Emission Map 片元着色器代码： #version 330 core out vec4 FragColor; in vec3 Normal; in vec3 FragPos; in vec2 TexCoords; struct Material { sampler2D diffuse;//漫反射贴图 sampler2D specular;//镜面光贴图 float shinine
辐照度贴图的生成算法分析
小孔明的专栏
02-14 1086
在读这篇博客的时候，需要读者具备一些基本的IBL（image-based lighting）的相关知识。 比如什么是辐射率，辐射度，立体角等相关的知识。还需要知道球坐标和笛卡尔坐标之间的相互转的关系等。 同时官方参考网址：https://learnopengl.com/PBR/IBL/Diffuse-irradiance 源代码也有：https://github.com/JoeyDeVries/L...
【内置渲染管线】Unity标准Shader解析（渲染模式，贴图类型）
纯技术流日常开发商业开发记录总结等
05-31 4911
438312501
OpenGL光照之光照贴图
一个小菜鸡的学习之路
06-11 1205
每个物体都拥有自己独特的材质从而对光照做出不同的反应的方法。这样子能够很容易在一个光照的场景中给每个物体一个独特的外观，但是这仍不能对一个物体的视觉输出提供足够多的灵活性。我们将整个物体的材质定义为一个整体，但现实世界中的物体通常并不只包含有一种材质，而是由多种材质所组成。想想一辆汽车：它的外壳非常有光泽，车窗会部分反射周围的环境，轮胎不会那么有光泽，所以它没有镜面高光，轮毂非常闪亮（如果你洗车了的话）。
关于Albedo贴图、颜色贴图、Metallic 贴图、Specular贴图、法线贴图、视差贴图、凹凸贴图、Height Map高度贴图、AO 贴图Occlusion 贴图、Emission 贴图等
热门推荐
weixin_44191050的博客
05-18 2万+
在学习unity的过程中，被各种贴图弄得晕头转向，为了弄清楚各种贴图，查询了很多资料，粗略的整理如下，只要耐心看完，对贴图的基本用法基本上就没问题了。 1.Albedo 贴图 （可以看做是Diffuse颜色贴图） Albedo：反照率[贴图]；用于体现模型的纹理，颜色。 反照率贴图本身是一张颜色与纹理的贴图。 该选项有贴图属性，也有颜色属性。 两个属性可以单独使用，也可以组合使用； 当颜色属性为纯白色时，则不影响贴图的效果； 当颜色属性为其他颜色时，则叠加贴图效果。 2.Metallic 贴图 ** 金属度
Unity Shader - Emission 自发光
Jave.Lin 的学习笔记
06-11 1万+
目录：Unity Shader - 知识点目录（先占位，后续持续更新） 原文：Emission 版本：2019.1 Emission Emission控制从表面发出的光的颜色和强度。当你在场景中使用Emission材质时，它以可见光源的形式出现。自发光。 Emission材质通常是用在GameObjects需要从内部亮了起来，如监视器上的屏幕，如汽车在夜间行驶时闪亮的仪表盘，或是再漆黑地方闪亮着...
【OpenGL】笔记十三、光照贴图
ycrsw的博客
05-22 492
1. 流程 简单的光照材质无法满足要求，接下来我们要对不同材质的物体在各个片段的反射做出精准控制 1.1 漫反射贴图 之前，我们对物体的漫反射做了简单的单色定义，现在我们加入纹理贴图，让纹理的颜色作为漫反射的颜色： ...
OpenGL3.3_Lighting_EmissionMap
08-12
OpenGL3.3_Lighting_EmissionMap
OPENGL 画地球 真实感超强-纹理贴图 光照 动画
09-05
OPENGL 画地球-纹理贴图 光照 动画 VS2005工程，需要gl glu glut glaux支持。 有任何问题可留言。
图形学-光照模型-凹凸贴图
03-27
MFC实现地球自转，并且可以通过滑动条以及按钮等组件控制效果，例如可通过按钮选择显示球体的线框图、冯氏光照模型，地球平面贴图或者凹凸地球贴图，在选择冯氏光照模型时，可以通过滑动条调整颜色，高光指数等。
Unity动态加载烘焙好的光照贴图
04-01
一个脚本解决动态加载预制体，贴图缺失的问题
Qt3d加载obj文件实现贴图和光照
03-27
使用 Qmesh 加载 obj 文件 使用 QtextureImage 加载贴图文件 使用 QDiffuseSpecularMaterial 提供光照 说明:官方示例中有创建场景相机等代码, cpp文件只包含载入核心代码.
Ray Tracing in One Weekend(中文翻译)
xiji333的博客
09-25 1万+
文章目录1. 写在前面2. Output an Image2.1 The PPM Image Format2.2 Creating an Image File3. The vec3 Class3.1 Variables and Methods3.2 vec3 Utility Functions3.3 Color Utility Functions4. Rays, a Simple Camera, and Background4.1 The ray Class4.2 Sending Rays Into the
OpenGL 立方体贴图(CubeMap)原理
xiji333的博客
04-17 2744
文章目录参考文章什么是立方体贴图创建一个立方体贴图采样方式 参考文章 Learn OpenGL 知乎—Sqazine 什么是立方体贴图 简单来说，立方体贴图就是一个包含了6个2D纹理的纹理，每个2D纹理都组成了立方体的一个面：一个有纹理的立方体。这样做的好处是什么？不妨假设我们使用的立方体是1×1×1的，那么从坐标原点到该立方体上的任意一点可以组成一个方向向量，该方向向量最终会击中立方体的某个面，从而获取与之对应的纹理值。如下图所示： 所以用立方体贴图来实现天空盒非常简单。 创建一个立方体贴图 由于它有6
LearnOpenGL 模型加载—模型(一 利用Assimp库解析obj文件)
xiji333的博客
03-27 2683
文章目录写在前面模型导入3D模型到OpenGL从Assimp到网格索引材质重大优化继续优化？总结 写在前面 原文链接。原文应该是github上的一个项目，本文主要用来记录一些知识点和自己遇到的问题。 模型 现在是时候接触Assimp并创建实际的加载和转换代码了。这个教程的目标是创建另一个类来完整地表示一个模型，或者说是包含多个网格，甚至是多个物体的模型。一个包含木制阳台、塔楼、甚至游泳池的房子可能仍会被加载为一个模型。我们会使用Assimp来加载模型，并将它转换(Translate)至多个在上一节中创建的M
射线与球体/三角面片求交、重心坐标、插值
xiji333的博客
09-14 1562
射线 已知射线方程为P(t)=Pˉ+t∗DˉP(t)=\bar{P}+t*\bar{D}P(t)=Pˉ+t∗Dˉ，其中Pˉ\bar{P}Pˉ为射线的起点(x0,y0,z0)(x_0,y_0,z_0)(x0​,y0​,z0​)，Dˉ\bar{D}Dˉ为射线的方向向量，其模长为111，只要知道距离ttt，我们就可以计算出对应点的坐标。 球体求交 不妨设球体的方程为(Xˉ−Cˉ)2=R2(\bar{X}-\bar{C})^2=R^2(Xˉ−Cˉ)2=R2，其中Xˉ\bar{X}Xˉ为球体上任意一点的坐标，Cˉ\b
unity 光照贴图
最新发布
10-17
光照贴图是一种用于增强场景光照效果的技术，它通过将场景中的光照信息渲染到纹理中，再将这些纹理应用到场景中的物体上，从而实现更加真实的光照效果。在Unity中，可以使用Lightmap来实现光照贴图。 具体来说，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值