LearnGL - 14 - MultiLight - 多光源

最新推荐文章于 2023-05-05 19:20:15 发布
最新推荐文章于 2023-05-05 19:20:15 发布
阅读量516 收藏
点赞数
分类专栏： OpenGL IMGUI 图形 文章标签： OpenGL OpenGL多光源 Multi-Lights
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linjf520/article/details/107705030
版权
OpenGL 同时被 3 个专栏收录
59 篇文章 11 订阅
订阅专栏
图形
49 篇文章 0 订阅
订阅专栏
IMGUI
4 篇文章 0 订阅
订阅专栏

文章目录


LearnGL - 学习笔记目录

前些篇：

这些演示光照计算中，分别对 方向光、点光源、聚光灯 类型的光源实现

这篇：我们将实现给 多光源 ，演示在场景中将摆放好 三种光源 的多个光源的效果

本人才疏学浅，如有什么错误，望不吝指出。

C++ 应用层的代码改动和核心代码

修改前

已成为历史的单光源代码：

    int Camera::render(std::vector<GameObject*>* render_vec_helper) {

        std::vector<MeshRenderer*> renderers;

        // 提取 renderers
        std::vector<GameObject*>::iterator begin = render_vec_helper->begin();
        register size_t count = render_vec_helper->size();
        int ret = 0;
        for (register size_t i = 0; i < count; i++) {
            GameObject* go = *(begin + i);
            if (!go->getActivedInherited()) continue;
            MeshRenderer* renderer = go->getComp<MeshRenderer>();
            if (renderer != NULL && renderer->getActivedInherited()) {
                renderers.push_back(renderer);
            }
        }

        // 排序 renderers
        std::sort(renderers.begin(), renderers.end(), rendererCmp);

        // 处理 renderers
        count = renderers.size();
        for (register size_t i = 0; i < count; i++) {
            MeshRenderer* renderer = renderers[i];
            Material* mat = renderer->getAttachMaterial();

            // retrive lights
            std::vector<Component*>* lights = Component::getComps<Light>();
            if (lights != NULL) {
                std::vector<Component*>::iterator begin = lights->begin();
                register size_t count = lights->size();
                // 先使用，再设置
                renderer->getAttachMaterial()->getShader()->use();


                for (size_t i = 0; i < count; i++) {
                    Light* light = (Light*)*(begin + i);
                    if (!light->getActivedInherited()) {
                        mat->getShader()->setVec4("LightPos", 0, 0, 0, 0);
                        mat->getShader()->setVec4("LightColor", 0, 0, 0, 0);
                        continue;
                    }
                    switch (light->getType())
                    {
                        // 方向光假设为平行光，就想太阳一样，超级远都一样照射着
                        // 所以不用判断
                    case LightType::Directional:
                    {
                        // light world direction
                        vec3 light_world_dir = -light->getDir();
                        mat->getShader()->setVec4("LightPos",
                            light_world_dir.x, light_world_dir.y, light_world_dir.z, 0);
                        //mat->getShader()->setVec4("LightPos",
                        //    0.0f,0.0f,1.0f, 0.0f);
                        // light color
                        mat->getShader()->setVec4("LightColor",
                            light->color.x, light->color.y, light->color.z, light->intensity);
                        break;
                    }
                    // TODO : 点光源 需要判断是否有作用交集，才设置
                    case LightType::Point:
                    {
                        // light world position
                        vec3 light_world_pos = light->getWPos();
                        mat->getShader()->setVec4("LightPos",
                            light_world_pos.x, light_world_pos.y, light_world_pos.z, 1);
                        mat->getShader()->setVec4("LightColor",
                            light->color.x, light->color.y, light->color.z, light->intensity);
                        mat->getShader()->setFloat("ATTEN_Kc", light->point_light_constantK);
                        mat->getShader()->setFloat("ATTEN_Kl", light->point_light_linearK);
                        mat->getShader()->setFloat("ATTEN_Kq", light->point_light_quadraticK);
                        mat->getShader()->setVec2("ATTEN_Range", light->point_or_spot_light_range,
                            (light->point_or_spot_light_range == 0.0f ? 0.0f : 1.0f / light->point_or_spot_light_range));
                        break;
                    }
                    // TODO : 聚光灯 需要判断是否有作用交集，才设置
                    case LightType::Spot:
                    {
                        // light world position
                        vec3 light_world_pos = light->getWPos();
                        mat->getShader()->setVec4("LightPos",
                            light_world_pos.x, light_world_pos.y, light_world_pos.z, 0.5f);
                        mat->getShader()->setVec4("LightColor",
                            light->color.x, light->color.y, light->color.z, light->intensity);
                        mat->getShader()->setFloat("ATTEN_Kc", light->point_light_constantK);
                        mat->getShader()->setFloat("ATTEN_Kl", light->point_light_linearK);
                        mat->getShader()->setFloat("ATTEN_Kq", light->point_light_quadraticK);
                        mat->getShader()->setVec2("ATTEN_Range", light->point_or_spot_light_range,
                            (light->point_or_spot_light_range == 0.0f ? 0.0f : 1.0f / light->point_or_spot_light_range));

                        vec3 light_world_dir = light->getDir();
                        mat->getShader()->setVec3("SpotLightDir",
                            light_world_dir.x, light_world_dir.y, light_world_dir.z);
                        mat->getShader()->setFloat("SpotLightFOL", D2R(light->spot_light_FOL * 0.5f));
                        if (light->fade_out_using_FOL_percent) {
                            mat->getShader()->setFloat("SpotLightFOL_FadeOut", D2R((light->spot_light_FOL * light->fade_out_FOL_percent) * 0.5f));
                        }
                        else {
                            mat->getShader()->setFloat("SpotLightFOL_FadeOut", D2R(light->spot_light_FOL_fade_out * 0.5f));
                        }
                        mat->getShader()->setFloat("SpotLightExp", light->spot_light_exp);
                        break;
                    }
                    default:
                        std::cerr << "unimplements light type : " << (int)light->getType() << "\n";
                        assert(false);
                        break;
                    }
                }
            }

            // camera pos
            vec3 wp = trans->get_world_pos();
            //vec3 wp = trans->local_position;
            mat->getShader()->setVec3("_CamWorldPos", wp.x, wp.y, wp.z);
            // projection matrix
            Camera::mesh_renderer_data_helper.proj = getProjectionMatrix();
            // view matrix
            Camera::mesh_renderer_data_helper.view = getViewMatrix();
            // camera pos
            Camera::mesh_renderer_data_helper.camWorldPos = wp;
            // render
            renderer->render(Camera::mesh_renderer_data_helper);
            ret++;
        }

        return ret;
    }

修改后

    int Camera::render(std::vector<GameObject*>* render_gos) {

        glClearColor(clearColor.x, clearColor.y, clearColor.z, clearColor.w);   // 设置清理颜色缓存时，填充的颜色值
        glClearDepthf(clearDepth);		                                        // 设置清理深度缓存时，填充的深度值
        glClear(clearFlag);				                                        // 清理颜色缓存 与 深度缓存

        std::vector<MeshRenderer*> renderers;

        // 提取 renderers
        std::vector<GameObject*>::iterator begin = render_gos->begin();
        register size_t count = render_gos->size();
        int ret = 0;
        for (register size_t i = 0; i < count; i++) {
            GameObject* go = *(begin + i);
            if (!go->getActivedInherited()) continue;
            MeshRenderer* renderer = go->getComp<MeshRenderer>();
            if (renderer != NULL && renderer->getActivedInherited()) {
                renderers.push_back(renderer);
            }
        }

        // 排序 renderers
        std::sort(renderers.begin(), renderers.end(), rendererCmp);

        // uniform 的名字缓存，128个字节应该够用了
        char uniform_name[128];
        // 灯光属性的 uniform 字符格式
        const char* uniform_format = "Lights[%d].%s";

        // 处理 renderers
        count = renderers.size();
        for (register size_t i = 0; i < count; i++) {
            MeshRenderer* renderer = renderers[i];
            Material* mat = renderer->getAttachMaterial();

            // retrive lights
            std::vector<Component*>* lights = Component::getComps<Light>();
            if (lights != NULL) {
                std::vector<Component*>::iterator begin = lights->begin();
                register size_t count = lights->size();
                // 先使用，再设置
                renderer->getAttachMaterial()->getShader()->use();

                size_t validatedLightCount = 0;
                for (size_t i = 0; i < count; i++) {
                    Light* light = (Light*)*(begin + i);
                    // 没有启用
                    if (!light->getActivedInherited()) {
                        continue;
                    }
                    switch (light->getType())
                    {
                        // 方向光假设为平行光，就想太阳一样，超级远都一样照射着
                        // 所以不用判断
                    case LightType::Directional: {
                        break;
                    }
                    case LightType::Point: {
                        // TODO : 点光源 需要判断是否有作用交集，才设置
                        break;
                    }
                    case LightType::Spot:
                    {
                        // TODO : 聚光灯 需要判断是否有作用交集，才设置
                        // 张角
                        sprintf_s(uniform_name, uniform_format, validatedLightCount, "SpotFOL");
                        mat->getShader()->setFloat(uniform_name, D2R(light->spot_light_FOL * 0.5f));

                        if (light->fade_out_using_FOL_percent) {
                            // 淡出张角角度
                            sprintf_s(uniform_name, uniform_format, validatedLightCount, "SpotFOL_FadeOut");
                            mat->getShader()->setFloat(uniform_name, D2R((light->spot_light_FOL * light->fade_out_FOL_percent) * 0.5f));
                        }
                        else {
                            // 淡出张角角度
                            sprintf_s(uniform_name, uniform_format, validatedLightCount, "SpotFOL_FadeOut");
                            mat->getShader()->setFloat(uniform_name, D2R(light->spot_light_FOL_fade_out * 0.5f));
                        }
                        break;
                    }
                    default:
                        std::cerr << "unimplements light type : " << (int)light->getType() << "\n";
                        assert(false);
                        break;
                    }

                    if (light->getType() == LightType::Directional || light->getType() == LightType::Spot) {
                        // 方向
                        vec3 light_world_dir = -light->getDir();
                        sprintf_s(uniform_name, uniform_format, validatedLightCount, "Direction");
                        mat->getShader()->setVec3(uniform_name, light_world_dir.x, light_world_dir.y, light_world_dir.z);
                    }

                    if (light->getType() == LightType::Point || light->getType() == LightType::Spot) {
                        // 坐标
                        vec3 light_world_pos = light->getWPos();
                        sprintf_s(uniform_name, uniform_format, validatedLightCount, "Position");
                        mat->getShader()->setVec3(uniform_name, light_world_pos.x, light_world_pos.y, light_world_pos.z);
                        // 常数项系数
                        sprintf_s(uniform_name, uniform_format, validatedLightCount, "ATTEN_Kc");
                        mat->getShader()->setFloat(uniform_name, light->point_light_constantK);
                        // 一次项系数
                        sprintf_s(uniform_name, uniform_format, validatedLightCount, "ATTEN_Kl");
                        mat->getShader()->setFloat(uniform_name, light->point_light_linearK);
                        // 二次项系数
                        sprintf_s(uniform_name, uniform_format, validatedLightCount, "ATTEN_Kq");
                        mat->getShader()->setFloat(uniform_name, light->point_light_quadraticK);
                        // 范围
                        sprintf_s(uniform_name, uniform_format, validatedLightCount, "ATTEN_Range");
                        mat->getShader()->setVec2(uniform_name, light->point_or_spot_light_range,
                            (light->point_or_spot_light_range == 0.0f ? 0.0f : 1.0f / light->point_or_spot_light_range));
                    }

                    // 颜色
                    sprintf_s(uniform_name, uniform_format, validatedLightCount, "Color");
                    mat->getShader()->setVec3(uniform_name, light->color.x, light->color.y, light->color.z);
                    // 强度
                    sprintf_s(uniform_name, uniform_format, validatedLightCount, "Intensity");
                    mat->getShader()->setFloat(uniform_name, light->intensity);
                    // 类型
                    sprintf_s(uniform_name, uniform_format, validatedLightCount, "Type");
                    mat->getShader()->setInt(uniform_name, (GLint)light->getType());
                    // 启用
                    sprintf_s(uniform_name, uniform_format, validatedLightCount, "Enabled");
                    mat->getShader()->setInt(uniform_name, 1);

                    validatedLightCount++;
                }
                // 如果没有满灯光数量，则给最后一个索引的设置没启用，这样 shader 判断后面灯光的都不用处理
                if (validatedLightCount < 10) {
                    sprintf_s(uniform_name, uniform_format, validatedLightCount, "Enabled");
                    mat->getShader()->setInt(uniform_name, 0);
                }
            }

            // camera pos
            vec3 wp = trans->get_world_pos();
            //vec3 wp = trans->local_position;
            mat->getShader()->setVec3("_CamWorldPos", wp.x, wp.y, wp.z);
            // projection matrix
            Camera::mesh_renderer_data_helper.proj = getProjectionMatrix();
            // view matrix
            Camera::mesh_renderer_data_helper.view = getViewMatrix();
            // camera pos
            Camera::mesh_renderer_data_helper.camWorldPos = wp;
            // render
            renderer->render(Camera::mesh_renderer_data_helper);
            ret++;
        }

        return ret;
    }

可以看到前后改动的地方就只是原来的单光源属性的 uniform 设置变成了光源数组中的 uniform 的设置

另外，我们可以看到有两个 TODO：

  • // TODO : 点光源 需要判断是否有作用交集，才设置
  • // TODO : 聚光灯 需要判断是否有作用交集，才设置

后续可以将其改为先检测光源的范围 BB 与渲染几何体的 BB （其中，BB的意思：Bounding Box包围盒）有交集后才传入该对象 shader 中来处理。

（目前我们的 Material 材质是 单个 shader 的，后续会再修改为：多个 pass ，类似 Unity 中的 ShaderLab 中的 Pass的作用）

Shader - my_lighting.glsl 核心改动

改动前

可以参考 LearnGL - 13.1 - SpotLight - 聚光灯 文章的完整 shader

改动后

// jave.lin - my_lighting.glsl - 光照模型处理

#include "/Include/my_global.glsl"

#ifndef _MY_LIGHTING__GLSL__
#define _MY_LIGHTING__GLSL__

#define DIRECTIONAL_LIGHT_TYPE 0
#define POINT_LIGHT_TYPE 1
#define SPOT_LIGHT_TYPE 2

// scene uniform
uniform vec4 _Ambient;		// .xyz 环境光颜色, .w 环境光系数
uniform int AmbientType;	// 环境光类别，[测试用]

// 材质属性 - 很多的属性可以合并到其他没有满4个分量的属性，但学习目的，为了可读性高，可以分开来
struct Material_t {
	float Glossy;			// 光滑度
	vec3 Emission;			// 自发光颜色
	vec3 DiffuseK;			// 漫反射系数
	vec3 SpecularK;			// 高光系数
};
uniform Material_t Material;

// 灯光属性 - 很多的属性可以合并到其他没有满4个分量的属性，但学习目的，为了可读性高，可以分开来
// 灯光属性也可以按类型来分为不同的材质结构体
// 但是为了编写方便，就没有分开了
struct LightData_t {
	// common properties
	int 	Enabled;		// 是否开启
	int 	Type;			// 灯光类似
	vec3 	Color;			// 灯光颜色
	float 	Intensity;		// 强度
	// directional or spot light
	vec3 	Direction;		// 方向光 或 聚光灯 照射方向
	// point or spot light
	vec3 	Position;		// 点光源 或 聚光灯 灯光世界坐标位置
	float 	ATTEN_Kc;		// 点光源 常数项系数
	float 	ATTEN_Kl;		// 点光源 一次项系数
	float 	ATTEN_Kq;		// 点光源 二次项系数
	vec2 	ATTEN_Range;	// 点光源 有效范围, .x == range, .y == 1.0 / range
	// spot light
	float 	SpotFOL; 		// 聚光灯的张角量，Field Of Light（弧度）
	float 	SpotFOL_FadeOut;// 这个边缘淡出的角度，必须小于 SpotFOL，否则没有效果
};
const uint MaxLightNum = 10;
uniform LightData_t Lights[MaxLightNum];

// ambient
vec3 getAmbient(vec3 albedo) {
	if (AmbientType == 0) 	return _Ambient.rgb * _Ambient.a;
	else 					return mix(_Ambient.rgb * _Ambient.a, albedo, _Ambient.a);
}

// point or spot light 的光距离衰减
float getDistanceAtten(float dist, LightData_t light) {		// 获取距离衰减
	// 由原来的 atten = 1 / (kc + kl * dist + kq * dist * dist) 改为只用一个 sommthstep就够了
	// smoothstep 的曲线取反，即：1 - smoothstep，结果的曲线也不错
	return 1 - smoothstep(0, light.ATTEN_Range.x, dist);
}

void phong_illumination(
    in vec3 worldNormal,
    in vec3 viewDir,
    in vec3 worldPos,
    out vec3 diffuse,
    out vec3 specular
    ) {
	for	(int i = 0; i < MaxLightNum; ++i) {
		LightData_t light = Lights[i];
		// 如何有一个没开启，则后面都没开启，这是需要应用层配合使用的规则
		if (light.Enabled == 0) break;
		// 光源的方向
		vec3 lightDir;
		// 衰减
		float atten = 1;
		// 方向光
		if (light.Type == DIRECTIONAL_LIGHT_TYPE) {
			lightDir = light.Direction;
		}
		// 点光源
		else {
			// 点光源 或是 聚光灯 都需要处理的
			lightDir = light.Position - worldPos; // 片段到光源的方向，简称：灯光方向
			float dist = length(lightDir);		// 片段到光源的距离
			lightDir *= dist == 0 ? 1 : 1.0 / dist; // 归一化
			atten = getDistanceAtten(dist, light);		// 获取距离衰减
			// 聚光灯
			if (light.Type == SPOT_LIGHT_TYPE) {
				float LdotSD = dot(lightDir, light.Direction);
				float angle = acos(LdotSD);
				if (angle < light.SpotFOL) {
					// 在 FOL 张角内
					if (angle > light.SpotFOL_FadeOut) {
						// 平滑边缘
						atten *= 1 - smoothstep(light.SpotFOL_FadeOut, light.SpotFOL, angle);
					}
				} else {
					// 不在 FOL 张角内
					atten = 0;
				}
			}
		}
		float D = max(0, dot(lightDir, worldNormal));
		diffuse += light.Color * light.Intensity * D * Material.DiffuseK * atten;
		vec3 H = normalize(lightDir + viewDir);
		float S = 0;
		if (D > 0) S = pow(max(0, dot(H, worldNormal)), Material.Glossy);
		specular += light.Color * light.Intensity * S * Material.SpecularK * atten;
	}
}

#endif

我这里的 多光源 的模型也比较的简单，就是之前的 Phong 模型的变种：
I = I a ⋅ K a + ∑ i = 0 n ( I d ⋅ K d ⋅ d o t ( N , L i ) + I s ⋅ K s ⋅ p o w ( d o t ( n o r m a l i z e ( L i + V ) , N ) , G l o s s y ) ) I=\green{I_a\cdot K_a}+\red{\sum_{i=0}^n} \blue{(}I_d\cdot K_d\cdot dot(N,L_i) + I_s\cdot K_s\cdot pow(dot(normalize(L_i + V),N),Glossy)\blue{)} I=Ia​⋅Ka​+∑i=0n​(Id​⋅Kd​⋅dot(N,Li​)+Is​⋅Ks​⋅pow(dot(normalize(Li​+V),N),Glossy))

留意到前面的 环境光 I a ⋅ K a \green{I_a\cdot K_a} Ia​⋅Ka​ 不参数叠加，之后后面的 漫反射 与 高光 都参与了叠加，使用了一个累加和： ∑ i = 0 n \red{\sum_{i=0}^n} ∑i=0n​

注意： 在 for 循环里我们做了一些优化

// 如何有一个没开启，则后面都没开启，这是需要应用层配合使用的规则
if (light.Enabled == 0) break;

对应着上面 C++ 层改动后的：

// 如果没有满灯光数量，则给最后一个索引的设置没启用，这样 shader 判断后面灯光的都不用处理
if(validatedLightCount < 10) {
    sprintf_s(uniform_name, light_format, validatedLightCount, "Enabled");
    mat->getShader()->setInt(uniform_name, 0);
}

效果

放置多个光源

  • 一个 方向光
  • 两个 点光源
  • 两个 聚光灯

C++ 应用接口就相当简单了，接口的设计参考了 Unity 的接口（我没有 Unity 源码，只是自己更具使用 Unity 习惯来设计）

目前没去制作 场景 的 导出、导入，先将就用用：

	// load scene
	SceneMgr::inst()->loadScene(new Scene());

	mainCamera->addComp(new Camera());
	mainCamera->getComp<Transform>()->local_position = vec3(0.0f, 2.0f, 10.0f);
	mainCamera->getTrans()->set_world_pos(vec3(-10.0f, 2.0f, 12.0f));
	mainCamera->getTrans()->set_world_rot(vec3(0.0, -21.0f, 0.0f));

	GameObject* camParentGO = new GameObject("Cam parent GO");
	camParentGO->add(mainCamera);

	SceneMgr::inst()->getRoot()->add(camParentGO);

	char name[128];

	// 一个 方向光
	{
		GameObject* lightGO = new GameObject();
		sprintf_s(name, "%s##%d", "DirectionalLight", lightGO->id());
		lightGO->set_name_copy_from(name);

		Light* lightComp = new Light();
		lightGO->addComp(lightComp);
		lightComp->setType(LightType::Directional);
		lightGO->addComp(new MyLightVisual());

		lightGO->getTrans()->set_world_pos(vec3(0.0f, 1.0f, 0.0f));

		SceneMgr::inst()->getRoot()->add(lightGO);
	}

	// 两个 点光源
	{
		vec3 offset[2] = {
			vec3(0, 2.0f, 2.0f),
			vec3(0, 2.0f, 4.0f)
		};
		vec3 color[2] = {
			vec3(1.0f, 0.0f, 0.0f),
			vec3(0.0f, 1.0f, 0.0f),
		};
		for (size_t i = 0; i < 2; i++) {
			GameObject* lightGO = new GameObject();
			sprintf_s(name, "%s##%d", "PointLight", lightGO->id());
			lightGO->set_name_copy_from(name);

			Light* lightComp = new Light();
			lightGO->addComp(lightComp);
			lightComp->setType(LightType::Point);
			lightComp->color = vec4(color[i], 0.5f);
			lightGO->addComp(new MyLightVisual());

			lightGO->getTrans()->set_world_pos(offset[i]);

			SceneMgr::inst()->getRoot()->add(lightGO);
		}
	}

	// 两个 聚光灯
	{
		vec3 offset[2] = {
			vec3(-2.0f, 0.0f, 0.0f),
			vec3(-2.0f, 0.0f, 2.0f)
		};
		vec3 rotate[2] = {
			vec3(0.0, -90.0f, 0.0f),
			vec3(0.0, -60.0f, 0.0f),
		};
		vec3 color[2] = {
			vec3(1.0f, 0.0f, 1.0f),
			vec3(1.0f, 1.0f, 0.0f),
		};
		for (size_t i = 0; i < 2; i++) {
			GameObject* lightGO = new GameObject();
			sprintf_s(name, "%s##%d", "SpotLight", lightGO->id());
			lightGO->set_name_copy_from(name);

			Light* lightComp = new Light();
			lightGO->addComp(lightComp);
			lightComp->setType(LightType::Spot);
			lightComp->color = vec4(color[i], 0.5f);
			lightGO->addComp(new MyLightVisual());

			lightGO->getTrans()->set_world_pos(offset[i]);
			lightGO->getTrans()->set_world_rot(rotate[i]);

			SceneMgr::inst()->getRoot()->add(lightGO);
		}
	}

	// geometry
	{
		for (size_t i = 0; i < 10; i++) {
			// in fs
			{
				// sphere
				GameObject* temp_go = new GameObject();
				sprintf_s(name, "%s##%d", "sphere", temp_go->id());
				temp_go->set_name_copy_from(name);
				temp_go->getTrans()->local_position = vec3(0, 0, i);
				MySphere_Testing_Includes* temp_comp = new MySphere_Testing_Includes();
				temp_go->addComp(temp_comp);
				SceneMgr::inst()->getRoot()->add(temp_go);
			}

			{
				// balloon cat
				GameObject* temp_go = new GameObject();
				sprintf_s(name, "%s##%d", "Balloon cat", temp_go->id());
				temp_go->set_name_copy_from(name);
				temp_go->getTrans()->local_position = vec3(1.2f, 0, i);
				temp_go->getTrans()->local_scale = vec3(3, 3, 3);
				MyBalloonCat_Testing_Includes* temp_comp = new MyBalloonCat_Testing_Includes();
				temp_go->addComp(temp_comp);
				SceneMgr::inst()->getRoot()->add(temp_go);
			}
		}
	} // end blinn phong

效果

在这里插入图片描述

咋一看，眼花缭乱！

添加了灯光 Gizmos 显示控制

所以我们添加了一个 ImGui 的编辑选项，让选中的光源对象才显示：

	// 灯光 Gizmos 显示方式
	enum class LightVisualType {
		ShowSelected,	// 显示选中
		ShowAll,		// 实现所有
		HideAll,		// 隐藏所有

		MAX_NUM			// 枚举最大数量
	};
	struct LightVisual {
	public:
		static const char* name[(size_t)LightVisualType::MAX_NUM];
		static LightVisualType value[(size_t)LightVisualType::MAX_NUM];
	};
	const char* LightVisual::name[(size_t)LightVisualType::MAX_NUM] = {
		"ShowSelected",
		"ShowAll",
		"HideAll",
	};
	LightVisualType LightVisual::value[(size_t)LightVisualType::MAX_NUM] = {
		LightVisualType::ShowSelected,	// 显示选中
		LightVisualType::ShowAll,		// 实现所有
		LightVisualType::HideAll,		// 隐藏所有
	};

...
	void MyLightVisual::update() {
		Component::update();
		...
		switch (MyLightVisual::visualType) {
		case LightVisualType::ShowSelected: {
			renderer->setActived(getOwner()->id() == Editing_Info::hierarchy_info.obj_id);
			break;
		}
		case LightVisualType::ShowAll: {
			renderer->setActived(true);
			break;
		}
		case LightVisualType::HideAll: {
			renderer->setActived(false);
			break;
		}
		default:
			break;
		}
	}

	void MyLightVisual::imgui_content() {
		Component::imgui_content();

		ImGui::Combo("Light Gizmos ShowType", (int*)&MyLightVisual::visualType, LightVisual::name, (int)LightVisualType::MAX_NUM);
	}

对应 GIF：
在这里插入图片描述

这也是临时的方案，后续会封装 Gizmos，因为，正确的处理是会对所有 GameObject 的 Gizmos 的同样处理。

添加了渲染队列控制

因为我们的灯光可视 Gizmos 是半透明的，所以我们也封装了一些临时处理的：渲染队列
在这里插入图片描述
设置方式可以是数值，也可以是枚举值，枚举值参考了 Unity 的数值：

	enum class RenderQueueType {
		Background	= 1000,	// 天空盒子
		Gemoetry	= 2000, // 不透明几何体
		AlphaTest	= 2500, // FS 带有 discard 的
		Transprent	= 3000, // 透明的几何体
		Gizmos		= 3500, // 开发调式用的 Gizmos 绘制
		Overlay		= 4000, // UI 
	};

如果不处理渲染队列问题，我们半透明对象可能会出现融混（Blending）效果不对的问题，所以才添加了这些功能。

渲染状态

在这里插入图片描述
目前只有小部分：线框模式、面向剔除、深度测试、深度写入、融混

上面说明半透明是上图的：Blend 选项部分的内容，可以设置 Factor 与 Equation

以后还会不全所有的参数设置：如：glPolygonOffset （类似Unity ShaderLab Pass 中的 Offset[u] [m]）、模板测试、等等，以后用到再添加。

所有这些渲染状态配置类的，后面会添加一章单独简述一篇。这里因为有些功能需要，而提前用到，顺便在此说明一下。

整体操作演示

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

References

  • 多光源 - 它里面的光照模型和我的不太一样，我的是自己在 Phong 模型上总结的变种经验模型。
Jave.Lin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图像处理领域术语英文对应
Henry_Zhao的博客
03-16 2986
图像配准：img registration 图像拼接：img stitching 计算机断层扫描： computer tomography
osg多光源的实现
jaggerjack330的博客
07-24 1383
网上查找了关于osg光源的设置，基本上都是一个光源的，后来查找了一些资料，包括osg官方的例子。其实多个光源的实现非常简单，只要多建立一个osg::Light的对象并设置对应参数即可。 以两个光源为例 osg::ref_ptr createLight(osg::ref_ptr node) { osg::ref_ptr lightRoot = new osg::Group(); lightR
OpenGL光源之 多光源
最新发布
少年的博客
05-05 339
不多讲解，直接上代码，代码上都有注释，草履虫都能看懂。本文的程序来自于，这一节内容我调试了好久，一下午才把Bug修复。总结，当你拿到别人的OpenGL代码时，首先你要看主程序中的外部依赖库和一些头文件你是否具有，然后你需要对着色器的文件地址进行修改，然后就是对资源如图片的文件地址进行修改。教程原文中的代码是具有Bug的，第一个Bug就是纹理过滤方式的设置，纹理过滤方式不能将放大纹理设置为多级渐进纹理GL_NEAREST_MIPMAP_NEAREST，不然你使用glGetError会报错的。
[OpenGL] 延迟渲染 - 多个点光源
(ง •̀_•́)ง
01-27 1820
概念引入        在前向渲染中，如果场景中有N个物体，M个光源，那么我们就需要对于每个光源下，每个物体逐一绘制，这也就意味着我们需要绘制N * M次。这意味着光照计算除了会随着光的数量增加而增加复杂度，还会随着场景复杂度而变得更加耗时。因此，在使用前向渲染的游戏中，往往会小心翼翼地控制场景中的光源数量，来保证游戏帧率。         可以看出，由于我们需要对每个物体进行处理，而有些...
OpenGL基础25：多光源（附简单GLSL配置）
加载中...
06-16 1589
到这里，光照基础就已经接近尾声了，当然对于光照渲染的学习，这可能只是百步中的一步，尽管如此，至少是做到了从 0 到 1 的一个过程，就像之前刚学会“HelloWorld”一样，一切伟大的行动和思想，都有一个微不足道的开始 再次声明：直至这一章，主要还是参考于https://learnopengl.com/，当然这不仅是翻译，也结合了不少其它的文献和教学视频，和原文略有不同，很多地方去掉了繁杂或不重要的描述，加入了自己的看法，整体更加整洁易懂 如有问题/错误，求反馈 一、GLSL配置 之前...
Opengl(WebGL)前向渲染中的基本光照(包括多光源)
vily_lei的专栏
09-18 860
Demo:http://www.artvily.com/sample?sample=lightBase Demo:http://www.artvily.com/sample?sample=lightGroup 如果打开报错，请清理一下缓存。 上面两张图分别为固定的简单光源和任意组织的多光源(lightGroup: 环境光, 平行光，点光源，聚光灯, 以及BlinnPhong光源) ...
从零开始手撸WebGL3D引擎8：里程碑3-一个多光源场景
聚焦游戏和图形引擎开发技术
05-10 827
目前状态 暂停了一段时间后，本周又搞了几天，实现了基于多pass的多光源前向渲染，加上之前实现的基本的scene和transform，勉强可以打个分支了，暂且算作里程碑3：simple scene。虽然代码里面还有很多TODO，但勉强可以看些效果了。先上个视频： undefined 基本功能 目前实现了一个简单的场景和基于组件的场景节点，支持Camera, Light 和 Mesh No
UnityShader学习教程之＜透明度渲染队列详解＞
xiongwen_li的博客
03-14 2090
Queue：渲染队列 渲染队列的值越小，渲染级别就越靠前，比如背景层就比如Background和Geometry显示的效果是Geometry在Background之上 值：Background背景层级别的渲染值为1000 Geometry几何体级别的渲染值为2000 AlphaTest 通道测试2450 Transparent 任何通道混合的对象使用该队列，带有透明效果的物体，玻璃...
【OpenGL4.0】GLSL渲染语言入门与VBO、VAO使用：绘制一个三角形
mmdev
06-03 374
以前都是用Cg的，现在改用GLSL，又要重新学，不过两种语言很多都是相通的。 下面的例子是实现绘制一个三角形的简单程序。采用了VBO（veretx buffer object）、VAO（vertex array object）等OpenGL的一些新特性。越往后发展，可编程管线肯定是大势所趋，OpenGL里原来的一些固定管线的内容肯定会被废弃掉。所以从现在开始写程序就要养成使用新特性、采用可编...
Shader 渲染队列的一个坑
Roadlun的博客
05-21 921
我遇到了如下问题：一个半透明的Plan，后面可以看到树，这是理想的效果换个角度，树看不到了。这是什么问题呢？因为默认的渲染队列是Geometry（几何体），树和paln的渲染队列在同一个队列，所以电脑分不清先渲染谁，只需在plan的shader里设置渲染队列为在Geometry后面的队列即可：Tags{"Queue"="Transparent"}或Tags{"Queue"="Geometry+1"...
Unity中的多光源
异次元的归来
04-06 1043
在Unity中，如果想要使用多光源，比如2个平行光，或者1个平行光+1个点光源，需要在额外的shader pass中进行处理： Pass { Tags { "LightMode" = "ForwardAdd" } Blend One One ZWrite Off CGPROGRAM ... ENDCG } 这里设置了blend mode，表示add pass渲染其他光源所得到的颜色会叠加到base pass上，而关闭ZWrite则是个优化，
OpenGL学习笔记一之光照篇六 多光源
飞飞飞的博客
05-05 672
转载自https://learnopengl-cn.github.io/02%20Lighting/06%20Multiple%20lights/ 我们在前面的教程中已经学习了许多关于OpenGL中光照的知识，其中包括冯氏着色(Phong Shading)、材质(Material)、光照贴图(Lighting Map)以及不同种类的投光物(Light Caster)。在这一节中，我们将结合之前...
[解读] GuiltyGearXrd‘s Art Style : The X Factor Between 2D and 3D - GGX 3D 渲染 2D 风格
Jave.Lin 的学习笔记
12-12 8147
--- 这篇我们将 2015 GDC中的 《罪恶装备》介绍的视频内容都笔录一下 --- # 目的 对视频笔录的目的：便于后续重新回顾、搜索、确定方案时，可以快速的查看到想要的内容，而不用重新查看一遍视频的内容 --- # 注意 本篇因为笔录视频内容，会包含 ==**巨量**== 的图片，所以如果在浏览本篇文章之前，==**您的浏览终端，如果是流量有限的话，就需要注意一下**==
使用点斜式求两直线的交点
Jave.Lin 的学习笔记
09-25 8062
点斜式求直线交点：m0 = (y1 - y0) / (x1 - x0);已知：P0=(X:150, Y:50); P1=(X:200, Y:200); P2=(X:50, Y:125); P3=(X:?, Y:?);直线：L1 = P0-P1; L2 = P2-P3;P3点是：从P2作平行于X轴的直线L2，直到与L1相交的点；两线相交于：P3 因此L1可以写成：L1 = P0-P3;求P3
HSV/HSB/HSL 色相、饱和度、亮度的色彩模型
Jave.Lin 的学习笔记
09-03 5434
什么是HSV/HSB/HSL 首先理解 HSV/HSB/HSL 都是什么 我理解： HSV : Hue, Saturate, Value HSB : Hue, Saturate, Brightness HSL : Hue, Saturate, Lightness（或是Luminance） Hue : 色相 Saturate : 饱和度 其中的Value、Brightness、Lightness...
Unity Shader - 搬砖日志 - URP PBR (抄作业篇，持续更新~)
Jave.Lin 的学习笔记
02-25 5367
PBR 主要渲染方程 Lo(p,wo)=∫Ω(kdcπ+ksDGF4(wo⋅n)(wi⋅n))Li(p,wi)(wi⋅n)dwi L_o(p,w_o)=\int_{\Omega}(k_d \frac{c}{\pi} + k_s \frac {D G F}{4(w_o \cdot n)(w_i \cdot n)}) L_i(p,w_i)(w_i \cdot n) dw_i Lo​(p,wo​)=∫Ω​(kd​πc​+ks​4(wo​⋅n)(wi​⋅n)DGF​)Li​(p,wi​)(wi​⋅n)dwi​ .
Blender - Subsurface Scattering（次表面散射） - 实现比较好的奶酪材质参数说明
Jave.Lin 的学习笔记
08-23 4209
文章目录什么是次表面散射建模、添加 SSS 材质 什么是次表面散射 Subsurface Scattering - 次表面散射，简写 SSS 以前没去了解过，但是发现，如果要制作光通透效果，还是要了解实现原理，对于参数调整也会得心应手 Subsurface Scattering (SSS) 的说明，我参考了一篇写得很不错的：【插播002】Subsurface 我自己总结理解为：光波在射入物体后，部分光波在物质中穿透，最后总物体的从射出，然后我们的眼睛（相机）捕抓到这些光波的颜色。 Radius（光
Unity Shader - Post Processing 15 - Height Fog (Plus) - 后效 高度雾 改进版 (Parallax)、模拟闪电在云层中SSS
Jave.Lin 的学习笔记
01-10 3260
文章目录环境问题Parallax 原理效果ProjectReferences 环境 Unity : 2018.2.11f1, 2019.4.30f1 Pipeline : Built-in RP Graphic API : DX / OpenGL ES 之前 使用 后效实现过：深度 + 高度雾 版本的效果，具体可以参考：Unity Shader PostProcessing - 11 - 雾效/深度雾效/高度雾/深度+高度雾 问题 因为之前写的高度雾会有一个问题：不论我的高度雾设置多高的雾 底下的 G
Unity Shader - Planar Shadow - 平面阴影
Jave.Lin 的学习笔记
01-23 3152
思路 将模型压扁后，绘制即可 完善 多个 Planner Shadow 重叠绘制时的 alpha 问题 使用 stencil buffer 来规避已经绘制过的即可 References 暂无
Unity - DrawCall, Batch, SetPassCall区别
Jave.Lin 的学习笔记
02-05 3058
一般我们 在实时渲染中，DC也就是 DrawCall 都会尽可能的降低他，以为着，CPU 与 GPU 的绘制沟通会减少 啥叫：DrawCall 已 OpenGL 为例，就是调用带有绘制功能的 API 的次数 如：DrawCall : 10 次，那就意味着调用了 glDrawXXXX 的 API 10 次 啥叫：SetPassCall Unity 中，就无缘无故多了个叫：SetPassCall 的家伙 其实早在以前的游戏引擎里，没有 pass 这么一个说法，说是 techni 的说法 因为这些都是封装的功

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值