Modern OpenGL :光照shader

最新推荐文章于 2024-02-05 15:55:23 发布
最新推荐文章于 2024-02-05 15:55:23 发布
阅读量408 收藏 2
点赞数
分类专栏： c++ OpenGL 图形 文章标签： shader opengl webgl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011760195/article/details/105568819
版权
OpenGL 同时被 3 个专栏收录
17 篇文章 5 订阅
订阅专栏
c++
11 篇文章 1 订阅
订阅专栏
图形
9 篇文章 0 订阅
订阅专栏

Modern OpenGL :光照shader

1. 前言

  采用shader实现了标准？ 冯氏光照模型。

2. 数学背景

老生长谈了。

  • 光照模型：冯氏光照模型（环境光+漫反射+镜面反射）
  • 光源类型：点光源

环境光通常是一个常量
a m b i e n t = C a ambient= C_{a} ambient=Ca​

漫反射与面的法向量N和光线向量L有关
d i f f u s e = C d ∗ m a x ( d o t ( N , L ) , 0 ) diffuse = C_{d} * max (dot (N , L),0) diffuse=Cd​∗max(dot(N,L),0)

镜面反射与面的法向量N和光线向量L以及视线向量V有关
s p e c u l a r = C s ∗ m a x ( d o t ( V , r e f l e c t ( − L , N ) ) , 0 ) s h i n i n e s s specular = C_{s} * max (dot (V , reflect(-L,N)),0)^{shininess} specular=Cs​∗max(dot(V,reflect(−L,N)),0)shininess

不同于平行光，点光源还有一个属性。其光照强度随距离D缩减
a t t e n u a t i o n = 1 D 2 attenuation = \frac{1}{D^2} attenuation=D21​
但是此公式在物体及其接近光源的时候亮度会及其高，因此一般采用如下变种
a t t e n u a t i o n = 1 C + A ∗ D + B ∗ D 2 attenuation = \frac{1}{C + A*D + B* D^2} attenuation=C+A∗D+B∗D21​

3. 实现

在这里插入图片描述
在这里插入图片描述
矩阵库是我自己的渣渣实现这里就不献丑放出来了，读者用glm就可以了。
特别地，当我使用vec3.data()、mat4.data()时，意指获取储存在当前向量或矩阵的元素的数组指针。

顶点类型

class vertex
{
public:
	vec3 position;
	vec3 normal;
	vec2 coord;
	vec4 color;
};

顶点着色器

#version 430

layout (location = 0) uniform mat4 pvm;
layout (location = 1) uniform mat4 model;


layout (location = 0) in vec3 position;
layout (location = 1) in vec3 normal;
layout (location = 2) in vec2 coord;
layout (location = 3) in vec4 color;

struct v2f{
	vec3 normal;
	vec2 coord;
	vec4 color;
	vec3 position;
};

out v2f vert_out;

void main(){

	vec4 position_ = vec4(position,1);
	vert_out.normal =  mat3(transpose(inverse(model))) * normal;
	vert_out.coord = coord;
	vert_out.color = color;
	vert_out.position = (model * position_).xyz;
	gl_Position = pvm * position_;
}

片段着色器

#version 430

//layout (location = 1) uniform sampler2D sampler;
layout (location = 2) uniform vec4 light_position;
layout (location = 3) uniform vec4 light_ambient;
layout (location = 4) uniform vec4 light_diffuse;
layout (location = 5) uniform vec4 light_specular;
layout (location = 6) uniform vec3 eye;

float specular_intensity = 32.0;

out vec4 o;

struct v2f{
	vec3 normal;
	vec2 coord;
	vec4 color;
	vec3 position;
};

in v2f vert_out;

void main() {
	
	vec3 normal = normalize(vert_out.normal);

	vec3 ambient = light_ambient.xyz;

	vec3 light_direction = normalize(light_position.xyz - vert_out.position);

	float diffuse_factor = dot(normal,light_direction);
	vec3 diffuse = vec3(0,0,0);
	vec3 specular = vec3(0,0,0);
	if (diffuse_factor > 0)
	{
        diffuse = light_diffuse.xyz * diffuse_factor ;

		vec3 vertex_eye = normalize(eye -vert_out.position );
		vec3 light_reflect = normalize(reflect(-light_direction, normal));
        float specular_factor = dot(vertex_eye,light_reflect);
        
		if (specular_factor > 0) 
		{
			specular_factor = pow(specular_factor, specular_intensity);
			specular = light_specular.xyz * specular_factor;
		}
		
	}

	float distance = length(light_position.xyz - vert_out.position);

    float attenuation = 10.0 / ( 1 + (distance*distance));  
	
	o = vert_out.color * vec4(ambient + (diffuse + specular) *attenuation,1);
}

全部实现

vec4 light_position = vec4(1, -1, 3, 0);
vec4 light_ambient(0.2, 0.2,0.2, 1);
vec4 light_diffuse(0.5, 0.5, 0.5,1);
vec4 light_specular(0.5, 0.5,0.5, 1);
vec3 eye(0, -3,3);

mat4 view = mat4::view(eye, vec3(0,0,0), vec3(0,1 ,0));
mat4 model_1(1.0);
mat4 model_2 = mat4::translate(0,0,0.5);
mat4 persp = matrix4::perspective(45.0*math::PId180,  800.0F/600.0F, 1.0F,1000.0f);

GLuint plane_vao;
GLuint cube_vao;
GLuint plane_vbo;
GLuint cube_vbo;
GLuint plane_ebo;
GLuint cube_ebo;
GLuint plane_ebo_size;
GLuint cube_ebo_size;
GLuint sphere_vao;
GLuint sphere_vbo;
GLuint sphere_ebo;
GLuint sphere_ebo_size;
GLuint shader_vert;
GLuint shader_frag;
GLuint program;

string vertex_shader = 
R"(
#version 430

layout (location = 0) uniform mat4 pvm;
layout (location = 1) uniform mat4 model;


layout (location = 0) in vec3 position;
layout (location = 1) in vec3 normal;
layout (location = 2) in vec2 coord;
layout (location = 3) in vec4 color;

struct v2f{
	vec3 normal;
	vec2 coord;
	vec4 color;
	vec3 position;
};

out v2f vert_out;

void main(){

	vec4 position_ = vec4(position,1);
	vert_out.normal =  mat3(transpose(inverse(model))) * normal;
	vert_out.coord = coord;
	vert_out.color = color;
	vert_out.position = (model * position_).xyz;
	gl_Position = pvm * position_;
}
)";

string fragment_shader =
R"(
#version 430

//layout (location = 1) uniform sampler2D sampler;
layout (location = 2) uniform vec4 light_position;
layout (location = 3) uniform vec4 light_ambient;
layout (location = 4) uniform vec4 light_diffuse;
layout (location = 5) uniform vec4 light_specular;
layout (location = 6) uniform vec3 eye;

float specular_intensity = 32.0;

out vec4 o;

struct v2f{
	vec3 normal;
	vec2 coord;
	vec4 color;
	vec3 position;
};

in v2f vert_out;

void main() {
	
	vec3 normal = normalize(vert_out.normal);

	vec3 ambient = light_ambient.xyz;

	vec3 light_direction = normalize(light_position.xyz - vert_out.position);

	float diffuse_factor = dot(normal,light_direction);
	vec3 diffuse = vec3(0,0,0);
	vec3 specular = vec3(0,0,0);
	if (diffuse_factor > 0)
	{
        diffuse = light_diffuse.xyz * diffuse_factor ;

		vec3 vertex_eye = normalize(eye -vert_out.position );
		vec3 light_reflect = normalize(reflect(-light_direction, normal));
        float specular_factor = dot(vertex_eye,light_reflect);
        
		if (specular_factor > 0) 
		{
			specular_factor = pow(specular_factor, specular_intensity);
			specular = light_specular.xyz * specular_factor;
		}
		
	}

	float distance = length(light_position.xyz - vert_out.position);

    float attenuation = 10.0 / ( 1 + (distance*distance));  
	
	o = vert_out.color * vec4(ambient + (diffuse + specular) *attenuation,1);
}

)";



void resource_init()
{
	glEnable(GL_DEPTH_TEST);
	glCullFace(GL_BACK);
	glEnable(GL_CULL_FACE);

	glClearColor(0.f, 0.f, .3f, 1.f);
	glViewport(0, 0, 800, 600);


	vector<vertex> vertices =
	{
		{{-10,-10,0},{0,0,1},{0,0},{0.5,0.5,0.5,1}},
		{{10,-10,0},{0,0,1},{1,0},{0.5,0.5,0.5,1}},
		{ {10,10,0},{0,0,1},{1,1},{0.5,0.5,0.5,1}},
		{{-10,10,0},{0,0,1},{0,1},{0.5,0.5,0.5,1}},
	};
	vector<GLuint> indices = 
	{
		0,1,2,0,2,3,
	};

	glGenVertexArrays(1, &plane_vao);
	glGenBuffers(1, &plane_vbo);
	glGenBuffers(1, &plane_ebo);
	glBindVertexArray(plane_vao);
	glBindBuffer(GL_ARRAY_BUFFER, plane_vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertex)*vertices.size(), vertices.data(), GL_STATIC_DRAW);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(vertex), (const void*)(0));
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(vertex), (const void*)(sizeof(float[3])));
	glEnableVertexAttribArray(2);
	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(vertex), (const void*)(sizeof(float[6])));
	glEnableVertexAttribArray(3);
	glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, sizeof(vertex), (const void*)(sizeof(float[8])));
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, plane_ebo);
	plane_ebo_size = indices.size();
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*plane_ebo_size, indices.data(), GL_STATIC_DRAW);
	
	vertices =
	{
		{{-0.5,-0.5,0.5},{0,0,1},{0,0},{1,1,1,1}},
		{{0.5,-0.5,0.5},{0,0,1},{1,0},{1,1,1,1}},
		{{0.5,0.5,0.5},{0,0,1},{1,1},{1,1,1,1}},
		{{-0.5,0.5,0.5},{0,0,1},{0,1},{1,1,1,1}},

		{{-0.5,-0.5,-0.5},{0,0,-1},{0,0},{1,1,1,1}},
		{{-0.5,0.5,-0.5},{0,0,-1},{0,1},{1,1,1,1}},
		{{0.5,0.5,-0.5},{0,0,-1},{1,1},{1,1,1,1}},
		{{0.5,-0.5,-0.5},{0,0,-1},{1,0},{1,1,1,1}},
		
		{{-0.5,-0.5,0.5},{0,-1,0},{0,0},{1,1,1,1}},
		{{-0.5,-0.5,-0.5},{0,-1,0},{1,0},{1,1,1,1}},
		{{0.5,-0.5,-0.5},{0,-1,0},{1,1},{1,1,1,1}},
		{{0.5,-0.5,0.5},{0,-1,0},{0,1},{1,1,1,1}},

		{{0.5,-0.5,0.5},{1,0,0},{0,0},{1,1,1,1}},
		{{0.5,-0.5,-0.5},{1,0,0},{1,0},{1,1,1,1}},
		{{0.5,0.5,-0.5},{1,0,0},{1,1},{1,1,1,1}},
		{{0.5,0.5,0.5},{1,0,0},{0,1},{1,1,1,1}},

		{{0.5,0.5,0.5},{0,1,0},{0,0},{1,1,1,1}},
		{{0.5,0.5,-0.5},{0,1,0},{1,0},{1,1,1,1}},
		{{-0.5,0.5,-0.5},{0,1,0},{1,1},{1,1,1,1}},
		{{-0.5,0.5,0.5},{0,1,0},{0,1},{1,1,1,1}},

		{{-0.5,0.5,0.5},{-1,0,0},{0,0},{1,1,1,1}},
		{{-0.5,0.5,-0.5},{-1,0,0},{1,0},{1,1,1,1}},
		{{-0.5,-0.5,-0.5},{-1,0,0},{1,1},{1,1,1,1}},
		{{-0.5,-0.5,0.5},{-1,0,0},{0,1},{1,1,1,1}},
	};
	indices =
	{
		0,1,2,0,2,3,
		4,5,6,4,6,7,
		8,9,10,8,10,11,
		12,13,14,12,14,15,
		16,17,18,16,18,19,
		20,21,22,20,22,23,
	};

	glGenVertexArrays(1, &cube_vao);
	glGenBuffers(1, &cube_vbo);
	glGenBuffers(1, &cube_ebo);
	glBindVertexArray(cube_vao);
	glBindBuffer(GL_ARRAY_BUFFER, cube_vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertex)*vertices.size(), vertices.data(), GL_STATIC_DRAW);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(vertex), (const void*)(0));
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(vertex), (const void*)(sizeof(float[3])));
	glEnableVertexAttribArray(2);
	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(vertex), (const void*)(sizeof(float[6])));
	glEnableVertexAttribArray(3);
	glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, sizeof(vertex), (const void*)(sizeof(float[8])));
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cube_ebo);
	cube_ebo_size = indices.size();
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*cube_ebo_size, indices.data(), GL_STATIC_DRAW);

	glBindVertexArray(0);
	
	GLint compiled = GL_FALSE;
	shader_vert = glCreateShader(GL_VERTEX_SHADER);
	const GLchar* src = reinterpret_cast<const GLchar*>(vertex_shader.data());
	glShaderSource(shader_vert, 1, &src, NULL);
	glCompileShader(shader_vert);

	shader_frag = glCreateShader(GL_FRAGMENT_SHADER);
	src = reinterpret_cast<const GLchar*>(fragment_shader.data());
	glShaderSource(shader_frag, 1, &src, NULL);
	glCompileShader(shader_frag);
	
	program = glCreateProgram();
	glAttachShader(program , shader_vert);
	glAttachShader(program , shader_frag);

	glLinkProgram(program );
	
	GLint size;
	glGetProgramiv(program , GL_INFO_LOG_LENGTH, &size);
	if (size > 0) {
		xgc::list<char> str(size);
		GLint len;
		glGetProgramInfoLog(program , size, &len, str.data());

		cout << str.data() << endl;
	}
	
}

float rotate_ = 0.0;


void _Render()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
	
	rotate_ += 0.01f;

	//vec4 light_position = (-vec4(cos(rotate_), sin(rotate_), 1, 0)) .normalize();

	auto R = mat4::rotate(vec3(1, 0, 0), rotate_);

	glUseProgram(program );
	glUniform4fv(2, 1, light_position.data());
	glUniform4fv(3, 1, light_ambient.data());
	glUniform4fv(4, 1, light_diffuse.data());
	glUniform4fv(5, 1, light_specular.data());
	glUniform3fv(6, 1, eye.data());

	auto pvm = persp * view * model_1;
	glUniformMatrix4fv(0, 1, GL_FALSE, pvm.data());
	glUniformMatrix4fv(1, 1, GL_FALSE, model_1.data());
	glBindVertexArray(plane_vao);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, plane_ebo);
	glDrawElements(GL_TRIANGLES, plane_ebo_size, GL_UNSIGNED_INT, NULL);

	auto _model = model_2 * R;
	pvm = persp * view * _model;
	glUniformMatrix4fv(0, 1, GL_FALSE, pvm.data());
	glUniformMatrix4fv(1, 1, GL_FALSE, _model.data());
	glBindVertexArray(cube_vao);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cube_ebo);
	glDrawElements(GL_TRIANGLES, cube_ebo_size, GL_UNSIGNED_INT, NULL);
}

int main(int argc, char** argv, char** envp)
{
	
	auto hr = glfwInit();
	glfwSetErrorCallback(error_callback);

	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); // OpenGL主版本号
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // OpenGL副版本号
	glfwWindowHint(GLFW_RESIZABLE, GL_TRUE);   //可改变大小 
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	hwnd = glfwCreateWindow(800, 600, "GLFW Window", NULL, NULL);
	glfwSetInputMode(hwnd, GLFW_RAW_MOUSE_MOTION, GLFW_TRUE);

	glfwMakeContextCurrent(hwnd);
	glfwSwapInterval(1);
	glfwSetFramebufferSizeCallback(hwnd, (GLFWframebuffersizefun)size_changed);
	glfwSetKeyCallback(hwnd, (GLFWkeyfun)key_board);
	glfwSetMouseButtonCallback(hwnd, MouseEvent);
	glfwSetScrollCallback(hwnd, MouseScrollEvent);

	auto err = glewInit();
	if (GLEW_OK != err) {
		std::cerr << "GLEW Error : " << glewGetErrorString(err) << std::endl;
		return err;
	}
	
	resource_init();
	
	while (!glfwWindowShouldClose(hwnd)) {

		_Render();
		
		glfwSwapBuffers(hwnd); 
		glfwPollEvents();
	}
	glfwDestroyWindow(hwnd);
	glfwTerminate();
	return 0;
}
_luna
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenGL高级光照
qq_44800780的博客
10-08 260
参考： https://learnopenglcn.github.io/05%20Advanced%20Lighting/01%20Advanced%20Lighting/ Blinn-Phong 冯氏光照不仅对真实光照有很好的近似，而且性能也很高。 但是它的镜面反射会在一些情况下出现问题，特别是物体反光度很低时，会导致大片（粗糙的）高光区域。下面这张图展示了当反光度为1.0时地板会出现的效果： ...
OpenGL泛光
qq_44800780的博客
10-10 650
参考： https://learnopenglcn.github.io/05%20Advanced%20Lighting/07%20Bloom/ 光晕效果可以使用一个后处理特效泛光来实现。泛光使所有明亮区域产生光晕效果。下面是一个使用了和没有使用光晕的对比（图片生成自虚幻引擎）： Bloom是我们能够注意到一个明亮的物体真的有种明亮的感觉。泛光可以极大提升场景中的光照效果，并提供了极大的效果提升...
OpenGL-- Shader 颜色 光照 3 光照贴图 LightMap_VS2015
05-25
http://blog.csdn.net/yulinxx/article/details/72720944
OpenGL-- Shader 颜色 光照 5 多光源 基础
06-02
OpenGL-- Shader 颜色 光照 5 多光源 基础 VS2015 http://blog.csdn.net/yulinxx/article/details/72838217
【OpenGL学习】OpenGL实现 基于Phong模型的基础光照
miyazono_的博客
01-30 1375
OpenGL实现 基于Phong模型的基础光照，推导了法线变换使用的逆转置矩阵
OpenGL原理与实践——核心模式（六）：光照贴图、光源分类以及多光源场景主要源码实现
最不正经的计算机专业学生
11-26 1038
本章主要以代码为主，理论理解即可。详细分析代码
第六章 opengl之光照（颜色）
Re_view的博客
03-06 575
第六章 opengl之光照（颜色）
OpenGL 入门（八）— 标准光照模型
最新发布
qq_40120946的博客
02-05 1295
一个通过计算环境光，漫反射，和镜面光分量的值来估计真实光照的模型。通过给每个没有被光照的物体很小的亮度，使其不是完全黑暗的，从而对全局光照进行估计。一个顶点/片段与光线方向越接近，光照会越强。使用了法向量来计算角度。反射光线的强度与表面法线和光源方向之间夹角的余弦值成正比。一个垂直于平面的单位向量。法线矩阵(Normal Matrix)： 一个3x3矩阵，或者说是没有平移的模型（或者模型-观察）矩阵。它也被以某种方式修改（逆转置），从而在应用非统一缩放时，保持法向量朝向正确的方向。
【OpenGL】基础光照
qq_38243831的博客
01-08 1257
现实世界中的光照是极其复杂，难以计算的，因此OpenGL的光照使用的是简化的模型，其中一个模型被称为冯氏光照模型环境(Ambient)光照漫反射(Diffuse)光照镜面(Specular)光照。
Learn-OpenGL:关于OpenGL的学习资料
04-30
Learn-OpenGL关于OpenGL的学习资料语言相关的书籍:C语言C语言我觉得是最值得任何程序员花大量的时间学习的语言.原因是:c语言不在可能随着时间的变化而产生太大的变动,最多也就是一点修修补补.可以说是一朝学会,终生...
Modern OpenGL Guide.pdf
05-25
本指南将教您使用OpenGL开发现代图形应用程序的基础知识。 关于此主题还有很多其他指南，但是在某些主要方面与本指南有所不同。 我们将不再讨论OpenGL规范的任何旧部分。 这意味着您将学会如何自己实现事物，而不是...
Modern OpenGL Guide_opengl_ComputerGraphics_TEACH_
09-28
This guide will teach you the basics of using Open G L to develop modern graphicsapplications. There are a lot of other guides on this topic but there are somemajor points where this guide differs ...
Modern Cryptography : Theory and Practice
09-19
第一章：一个简单的通信游戏 第二章：防守与攻击 第三章：概率论和信息论 第四章：计算复杂性 第五章：代数基础 第六章：数论 第七章：加密-对称技术 第八章：加密-非对称技术 ...第十章：数据完整性技术 ...
OpenGL 的 shader language 例子
05-23
2. **Shader的概念**：Shader是在GPU上运行的小型程序，它们负责处理图形管道的不同阶段，如顶点变换、光照计算、纹理映射等。OpenGL支持两种主要类型的着色器：顶点着色器和片段着色器，还有其他如几何着色器、 ...
OpenGL（十）——基础光照
GZ的博客
05-08 1403
现实世界光照十分复杂，冯氏光照模型是对现实世界光照的抽象，主要由3部分组成，环境ambient，漫反射diffuse，镜面specular光照。环境光照：物体永远不会是完全黑暗，使用一个环境光照常量，永远给物体一些颜色。漫反射光照：模拟光源对物体方向性影响。物体某一部分越是对着光源越亮。镜面光照：模拟有光泽物体上面的亮点，镜面光照颜色更倾向于光的颜色。
OpenGL-Shader
07-09
共六章1.基础章节,从Shader1.0版本到新的4.5版本,介绍每一个版本中特性的用法;2.Tesslattion Shader应用/基础案例分析3.Gemotry Shader应用/基础案例分析4.Compute Shader应用/基础案例分析5.通过大量案例讲解分析/结合新特性，介绍用法6.性能调优，如果借助shader加速应用,让你的程序支撑百万级别的场景对象轻松应对
OpenGL-- Shader 颜色 光照 5 多光源
...
06-02 1553
OGLMultipleLights-OpenGL-- Shader 颜色 光照 5 多光源
OpenGL第七章 基础光照
ahang的博客
05-24 517
这里的基础光照使用的是： 冯氏光照模型 冯氏光照模型分为三部分 1环境光照（Ambient） 把环境光照添加到场景里非常简单。 我们用光的颜色乘以一个很小的常量环境因子，再乘以物体的颜色，然后将最终结果作为片段的颜色 2漫反射（diffuse） 我们知道两个单位向量的夹角越小，它们点乘的结果越倾向于1。 当两个向量的夹角为90度的时候，点乘会变为0。这同样适用于θ，θ越大，光对片段颜色的影响就应该越小。 那么此时我们就要一个法线方向和一个指向光源的方向（图形学里面光照方向指的是从每一个世界坐标出发指向
第八章 opengl之光照（材质）
Re_view的博客
03-07 552
第八章 opengl之光照（材质）
探索Modern Perl：电子书精华
"现代Perl 电子书（Modern Perl）是一本由chromatic编写的关于Perl编程语言的书籍，主要关注现代Perl的使用和实践。本书强调了Perl 5的最新特性和最佳实践，同时也提及了Perl 6的相关内容。" 在《现代Perl》一书中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值