3 Copyright (C) 2021 Liso <anlismon@gmail.com>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 #include "client/shadows/dynamicshadowsrender.h"
23 #include "client/shadows/shadowsScreenQuad.h"
24 #include "client/shadows/shadowsshadercallbacks.h"
27 #include "util/string.h"
28 #include "client/shader.h"
29 #include "client/client.h"
30 #include "client/clientmap.h"
33 ShadowRenderer::ShadowRenderer(IrrlichtDevice *device, Client *client) :
34 m_smgr(device->getSceneManager()), m_driver(device->getVideoDriver()),
35 m_client(client), m_current_frame(0),
36 m_perspective_bias_xy(0.8), m_perspective_bias_z(0.5)
40 m_shadows_supported = true; // assume shadows supported. We will check actual support in initialize
41 m_shadows_enabled = true;
43 m_shadow_strength_gamma = g_settings->getFloat("shadow_strength_gamma");
44 if (std::isnan(m_shadow_strength_gamma))
45 m_shadow_strength_gamma = 1.0f;
46 m_shadow_strength_gamma = core::clamp(m_shadow_strength_gamma, 0.1f, 10.0f);
48 m_shadow_map_max_distance = g_settings->getFloat("shadow_map_max_distance");
50 m_shadow_map_texture_size = g_settings->getFloat("shadow_map_texture_size");
52 m_shadow_map_texture_32bit = g_settings->getBool("shadow_map_texture_32bit");
53 m_shadow_map_colored = g_settings->getBool("shadow_map_color");
54 m_shadow_samples = g_settings->getS32("shadow_filters");
55 m_map_shadow_update_frames = g_settings->getS16("shadow_update_frames");
58 ShadowRenderer::~ShadowRenderer()
60 // call to disable releases dynamically allocated resources
63 if (m_shadow_depth_cb)
64 delete m_shadow_depth_cb;
65 if (m_shadow_depth_entity_cb)
66 delete m_shadow_depth_entity_cb;
67 if (m_shadow_depth_trans_cb)
68 delete m_shadow_depth_trans_cb;
70 delete m_shadow_mix_cb;
71 m_shadow_node_array.clear();
74 if (shadowMapTextureDynamicObjects)
75 m_driver->removeTexture(shadowMapTextureDynamicObjects);
77 if (shadowMapTextureFinal)
78 m_driver->removeTexture(shadowMapTextureFinal);
80 if (shadowMapTextureColors)
81 m_driver->removeTexture(shadowMapTextureColors);
83 if (shadowMapClientMap)
84 m_driver->removeTexture(shadowMapClientMap);
86 if (shadowMapClientMapFuture)
87 m_driver->removeTexture(shadowMapClientMapFuture);
90 void ShadowRenderer::disable()
92 m_shadows_enabled = false;
93 if (shadowMapTextureFinal) {
94 m_driver->setRenderTarget(shadowMapTextureFinal, true, true,
95 video::SColor(255, 255, 255, 255));
96 m_driver->setRenderTarget(0, true, true);
100 void ShadowRenderer::initialize()
102 auto *gpu = m_driver->getGPUProgrammingServices();
105 if (m_shadows_supported && gpu && m_driver->queryFeature(video::EVDF_ARB_GLSL)) {
108 m_shadows_supported = false;
110 warningstream << "Shadows: GLSL Shader not supported on this system."
115 m_texture_format = m_shadow_map_texture_32bit
116 ? video::ECOLOR_FORMAT::ECF_R32F
117 : video::ECOLOR_FORMAT::ECF_R16F;
119 m_texture_format_color = m_shadow_map_texture_32bit
120 ? video::ECOLOR_FORMAT::ECF_G32R32F
121 : video::ECOLOR_FORMAT::ECF_G16R16F;
123 m_shadows_enabled &= m_shadows_supported;
127 size_t ShadowRenderer::addDirectionalLight()
129 m_light_list.emplace_back(m_shadow_map_texture_size,
131 video::SColor(255, 255, 255, 255), m_shadow_map_max_distance);
132 return m_light_list.size() - 1;
135 DirectionalLight &ShadowRenderer::getDirectionalLight(u32 index)
137 return m_light_list[index];
140 size_t ShadowRenderer::getDirectionalLightCount() const
142 return m_light_list.size();
145 f32 ShadowRenderer::getMaxShadowFar() const
147 if (!m_light_list.empty()) {
148 float zMax = m_light_list[0].getFarValue();
154 void ShadowRenderer::setShadowIntensity(float shadow_intensity)
156 m_shadow_strength = pow(shadow_intensity, 1.0f / m_shadow_strength_gamma);
157 if (m_shadow_strength > 1E-2)
163 void ShadowRenderer::addNodeToShadowList(
164 scene::ISceneNode *node, E_SHADOW_MODE shadowMode)
166 m_shadow_node_array.emplace_back(NodeToApply(node, shadowMode));
169 void ShadowRenderer::removeNodeFromShadowList(scene::ISceneNode *node)
171 for (auto it = m_shadow_node_array.begin(); it != m_shadow_node_array.end();) {
172 if (it->node == node) {
173 it = m_shadow_node_array.erase(it);
181 void ShadowRenderer::updateSMTextures()
183 if (!m_shadows_enabled || m_smgr->getActiveCamera() == nullptr) {
187 if (!shadowMapTextureDynamicObjects) {
189 shadowMapTextureDynamicObjects = getSMTexture(
190 std::string("shadow_dynamic_") + itos(m_shadow_map_texture_size),
191 m_texture_format, true);
192 assert(shadowMapTextureDynamicObjects != nullptr);
195 if (!shadowMapClientMap) {
197 shadowMapClientMap = getSMTexture(
198 std::string("shadow_clientmap_") + itos(m_shadow_map_texture_size),
199 m_shadow_map_colored ? m_texture_format_color : m_texture_format,
201 assert(shadowMapClientMap != nullptr);
204 if (!shadowMapClientMapFuture && m_map_shadow_update_frames > 1) {
205 shadowMapClientMapFuture = getSMTexture(
206 std::string("shadow_clientmap_bb_") + itos(m_shadow_map_texture_size),
207 m_shadow_map_colored ? m_texture_format_color : m_texture_format,
209 assert(shadowMapClientMapFuture != nullptr);
212 if (m_shadow_map_colored && !shadowMapTextureColors) {
213 shadowMapTextureColors = getSMTexture(
214 std::string("shadow_colored_") + itos(m_shadow_map_texture_size),
215 m_shadow_map_colored ? m_texture_format_color : m_texture_format,
217 assert(shadowMapTextureColors != nullptr);
220 // The merge all shadowmaps texture
221 if (!shadowMapTextureFinal) {
222 video::ECOLOR_FORMAT frt;
223 if (m_shadow_map_texture_32bit) {
224 if (m_shadow_map_colored)
225 frt = video::ECOLOR_FORMAT::ECF_A32B32G32R32F;
227 frt = video::ECOLOR_FORMAT::ECF_R32F;
229 if (m_shadow_map_colored)
230 frt = video::ECOLOR_FORMAT::ECF_A16B16G16R16F;
232 frt = video::ECOLOR_FORMAT::ECF_R16F;
234 shadowMapTextureFinal = getSMTexture(
235 std::string("shadowmap_final_") + itos(m_shadow_map_texture_size),
237 assert(shadowMapTextureFinal != nullptr);
240 if (!m_shadow_node_array.empty() && !m_light_list.empty()) {
241 bool reset_sm_texture = false;
243 // detect if SM should be regenerated
244 for (DirectionalLight &light : m_light_list) {
245 if (light.should_update_map_shadow) {
246 light.should_update_map_shadow = false;
248 reset_sm_texture = true;
252 video::ITexture* shadowMapTargetTexture = shadowMapClientMapFuture;
253 if (shadowMapTargetTexture == nullptr)
254 shadowMapTargetTexture = shadowMapClientMap;
256 // Update SM incrementally:
257 for (DirectionalLight &light : m_light_list) {
258 // Static shader values.
259 for (auto cb : {m_shadow_depth_cb, m_shadow_depth_entity_cb, m_shadow_depth_trans_cb})
261 cb->MapRes = (f32)m_shadow_map_texture_size;
262 cb->MaxFar = (f32)m_shadow_map_max_distance * BS;
263 cb->PerspectiveBiasXY = getPerspectiveBiasXY();
264 cb->PerspectiveBiasZ = getPerspectiveBiasZ();
265 cb->CameraPos = light.getFuturePlayerPos();
268 // set the Render Target
269 // right now we can only render in usual RTT, not
270 // Depth texture is available in irrlicth maybe we
271 // should put some gl* fn here
274 if (m_current_frame < m_map_shadow_update_frames) {
275 m_driver->setRenderTarget(shadowMapTargetTexture, reset_sm_texture, true,
276 video::SColor(255, 255, 255, 255));
277 renderShadowMap(shadowMapTargetTexture, light);
279 // Render transparent part in one pass.
280 // This is also handled in ClientMap.
281 if (m_current_frame == m_map_shadow_update_frames - 1) {
282 if (m_shadow_map_colored) {
283 m_driver->setRenderTarget(0, false, false);
284 m_driver->setRenderTarget(shadowMapTextureColors,
285 true, false, video::SColor(255, 255, 255, 255));
287 renderShadowMap(shadowMapTextureColors, light,
288 scene::ESNRP_TRANSPARENT);
290 m_driver->setRenderTarget(0, false, false);
293 reset_sm_texture = false;
296 // move to the next section
297 if (m_current_frame <= m_map_shadow_update_frames)
300 // pass finished, swap textures and commit light changes
301 if (m_current_frame == m_map_shadow_update_frames) {
302 if (shadowMapClientMapFuture != nullptr)
303 std::swap(shadowMapClientMapFuture, shadowMapClientMap);
305 // Let all lights know that maps are updated
306 for (DirectionalLight &light : m_light_list)
307 light.commitFrustum();
312 void ShadowRenderer::update(video::ITexture *outputTarget)
314 if (!m_shadows_enabled || m_smgr->getActiveCamera() == nullptr) {
320 if (shadowMapTextureFinal == nullptr) {
324 if (!m_shadow_node_array.empty() && !m_light_list.empty()) {
326 for (DirectionalLight &light : m_light_list) {
327 // Static shader values for entities are set in updateSMTextures
328 // SM texture for entities is not updated incrementally and
329 // must by updated using current player position.
330 m_shadow_depth_entity_cb->CameraPos = light.getPlayerPos();
332 // render shadows for the n0n-map objects.
333 m_driver->setRenderTarget(shadowMapTextureDynamicObjects, true,
334 true, video::SColor(255, 255, 255, 255));
335 renderShadowObjects(shadowMapTextureDynamicObjects, light);
336 // clear the Render Target
337 m_driver->setRenderTarget(0, false, false);
339 // in order to avoid too many map shadow renders,
340 // we should make a second pass to mix clientmap shadows and
341 // entities shadows :(
342 m_screen_quad->getMaterial().setTexture(0, shadowMapClientMap);
343 // dynamic objs shadow texture.
344 if (m_shadow_map_colored)
345 m_screen_quad->getMaterial().setTexture(1, shadowMapTextureColors);
346 m_screen_quad->getMaterial().setTexture(2, shadowMapTextureDynamicObjects);
348 m_driver->setRenderTarget(shadowMapTextureFinal, false, false,
349 video::SColor(255, 255, 255, 255));
350 m_screen_quad->render(m_driver);
351 m_driver->setRenderTarget(0, false, false);
357 void ShadowRenderer::drawDebug()
359 /* this code just shows shadows textures in screen and in ONLY for debugging*/
361 // this is debug, ignore for now.
362 if (shadowMapTextureFinal)
363 m_driver->draw2DImage(shadowMapTextureFinal,
364 core::rect<s32>(0, 50, 128, 128 + 50),
365 core::rect<s32>({0, 0}, shadowMapTextureFinal->getSize()));
367 if (shadowMapClientMap)
368 m_driver->draw2DImage(shadowMapClientMap,
369 core::rect<s32>(0, 50 + 128, 128, 128 + 50 + 128),
370 core::rect<s32>({0, 0}, shadowMapTextureFinal->getSize()));
372 if (shadowMapTextureDynamicObjects)
373 m_driver->draw2DImage(shadowMapTextureDynamicObjects,
374 core::rect<s32>(0, 128 + 50 + 128, 128,
375 128 + 50 + 128 + 128),
376 core::rect<s32>({0, 0}, shadowMapTextureDynamicObjects->getSize()));
378 if (m_shadow_map_colored && shadowMapTextureColors) {
380 m_driver->draw2DImage(shadowMapTextureColors,
381 core::rect<s32>(128,128 + 50 + 128 + 128,
382 128 + 128, 128 + 50 + 128 + 128 + 128),
383 core::rect<s32>({0, 0}, shadowMapTextureColors->getSize()));
389 video::ITexture *ShadowRenderer::getSMTexture(const std::string &shadow_map_name,
390 video::ECOLOR_FORMAT texture_format, bool force_creation)
392 if (force_creation) {
393 return m_driver->addRenderTargetTexture(
394 core::dimension2du(m_shadow_map_texture_size,
395 m_shadow_map_texture_size),
396 shadow_map_name.c_str(), texture_format);
399 return m_driver->getTexture(shadow_map_name.c_str());
402 void ShadowRenderer::renderShadowMap(video::ITexture *target,
403 DirectionalLight &light, scene::E_SCENE_NODE_RENDER_PASS pass)
405 m_driver->setTransform(video::ETS_VIEW, light.getFutureViewMatrix());
406 m_driver->setTransform(video::ETS_PROJECTION, light.getFutureProjectionMatrix());
408 // Operate on the client map
409 for (const auto &shadow_node : m_shadow_node_array) {
410 if (strcmp(shadow_node.node->getName(), "ClientMap") != 0)
413 ClientMap *map_node = static_cast<ClientMap *>(shadow_node.node);
415 video::SMaterial material;
416 if (map_node->getMaterialCount() > 0) {
417 // we only want the first material, which is the one with the albedo info
418 material = map_node->getMaterial(0);
421 material.BackfaceCulling = false;
422 material.FrontfaceCulling = true;
424 if (m_shadow_map_colored && pass != scene::ESNRP_SOLID) {
425 material.MaterialType = (video::E_MATERIAL_TYPE) depth_shader_trans;
428 material.MaterialType = (video::E_MATERIAL_TYPE) depth_shader;
429 material.BlendOperation = video::EBO_MIN;
432 m_driver->setTransform(video::ETS_WORLD,
433 map_node->getAbsoluteTransformation());
435 map_node->renderMapShadows(m_driver, material, pass, m_current_frame, m_map_shadow_update_frames);
440 void ShadowRenderer::renderShadowObjects(
441 video::ITexture *target, DirectionalLight &light)
443 m_driver->setTransform(video::ETS_VIEW, light.getViewMatrix());
444 m_driver->setTransform(video::ETS_PROJECTION, light.getProjectionMatrix());
446 for (const auto &shadow_node : m_shadow_node_array) {
447 // we only take care of the shadow casters
448 if (shadow_node.shadowMode == ESM_RECEIVE ||
449 strcmp(shadow_node.node->getName(), "ClientMap") == 0)
452 // render other objects
453 u32 n_node_materials = shadow_node.node->getMaterialCount();
454 std::vector<s32> BufferMaterialList;
455 std::vector<std::pair<bool, bool>> BufferMaterialCullingList;
456 std::vector<video::E_BLEND_OPERATION> BufferBlendOperationList;
457 BufferMaterialList.reserve(n_node_materials);
458 BufferMaterialCullingList.reserve(n_node_materials);
459 BufferBlendOperationList.reserve(n_node_materials);
461 // backup materialtype for each material
463 // and replace it by our "depth" shader
464 for (u32 m = 0; m < n_node_materials; m++) {
465 auto ¤t_mat = shadow_node.node->getMaterial(m);
467 BufferMaterialList.push_back(current_mat.MaterialType);
468 current_mat.MaterialType =
469 (video::E_MATERIAL_TYPE)depth_shader_entities;
471 BufferMaterialCullingList.emplace_back(
472 (bool)current_mat.BackfaceCulling, (bool)current_mat.FrontfaceCulling);
473 BufferBlendOperationList.push_back(current_mat.BlendOperation);
475 current_mat.BackfaceCulling = true;
476 current_mat.FrontfaceCulling = false;
479 m_driver->setTransform(video::ETS_WORLD,
480 shadow_node.node->getAbsoluteTransformation());
481 shadow_node.node->render();
483 // restore the material.
485 for (u32 m = 0; m < n_node_materials; m++) {
486 auto ¤t_mat = shadow_node.node->getMaterial(m);
488 current_mat.MaterialType = (video::E_MATERIAL_TYPE) BufferMaterialList[m];
490 current_mat.BackfaceCulling = BufferMaterialCullingList[m].first;
491 current_mat.FrontfaceCulling = BufferMaterialCullingList[m].second;
492 current_mat.BlendOperation = BufferBlendOperationList[m];
495 } // end for caster shadow nodes
498 void ShadowRenderer::mixShadowsQuad()
503 * @Liso's disclaimer ;) This function loads the Shadow Mapping Shaders.
504 * I used a custom loader because I couldn't figure out how to use the base
505 * Shaders system with custom IShaderConstantSetCallBack without messing up the
506 * code too much. If anyone knows how to integrate this with the standard MT
507 * shaders, please feel free to change it.
510 void ShadowRenderer::createShaders()
512 video::IGPUProgrammingServices *gpu = m_driver->getGPUProgrammingServices();
514 if (depth_shader == -1) {
515 std::string depth_shader_vs = getShaderPath("shadow_shaders", "pass1_vertex.glsl");
516 if (depth_shader_vs.empty()) {
517 m_shadows_supported = false;
518 errorstream << "Error shadow mapping vs shader not found." << std::endl;
521 std::string depth_shader_fs = getShaderPath("shadow_shaders", "pass1_fragment.glsl");
522 if (depth_shader_fs.empty()) {
523 m_shadows_supported = false;
524 errorstream << "Error shadow mapping fs shader not found." << std::endl;
527 m_shadow_depth_cb = new ShadowDepthShaderCB();
529 depth_shader = gpu->addHighLevelShaderMaterial(
530 readShaderFile(depth_shader_vs).c_str(), "vertexMain",
532 readShaderFile(depth_shader_fs).c_str(), "pixelMain",
533 video::EPST_PS_1_2, m_shadow_depth_cb, video::EMT_ONETEXTURE_BLEND);
535 if (depth_shader == -1) {
536 // upsi, something went wrong loading shader.
537 delete m_shadow_depth_cb;
538 m_shadow_depth_cb = nullptr;
539 m_shadows_enabled = false;
540 m_shadows_supported = false;
541 errorstream << "Error compiling shadow mapping shader." << std::endl;
545 // HACK, TODO: investigate this better
546 // Grab the material renderer once more so minetest doesn't crash
548 m_driver->getMaterialRenderer(depth_shader)->grab();
551 // This creates a clone of depth_shader with base material set to EMT_SOLID,
552 // because entities won't render shadows with base material EMP_ONETEXTURE_BLEND
553 if (depth_shader_entities == -1) {
554 std::string depth_shader_vs = getShaderPath("shadow_shaders", "pass1_vertex.glsl");
555 if (depth_shader_vs.empty()) {
556 m_shadows_supported = false;
557 errorstream << "Error shadow mapping vs shader not found." << std::endl;
560 std::string depth_shader_fs = getShaderPath("shadow_shaders", "pass1_fragment.glsl");
561 if (depth_shader_fs.empty()) {
562 m_shadows_supported = false;
563 errorstream << "Error shadow mapping fs shader not found." << std::endl;
566 m_shadow_depth_entity_cb = new ShadowDepthShaderCB();
568 depth_shader_entities = gpu->addHighLevelShaderMaterial(
569 readShaderFile(depth_shader_vs).c_str(), "vertexMain",
571 readShaderFile(depth_shader_fs).c_str(), "pixelMain",
572 video::EPST_PS_1_2, m_shadow_depth_entity_cb);
574 if (depth_shader_entities == -1) {
575 // upsi, something went wrong loading shader.
576 delete m_shadow_depth_entity_cb;
577 m_shadow_depth_entity_cb = nullptr;
578 m_shadows_enabled = false;
579 m_shadows_supported = false;
580 errorstream << "Error compiling shadow mapping shader (dynamic)." << std::endl;
584 // HACK, TODO: investigate this better
585 // Grab the material renderer once more so minetest doesn't crash
587 m_driver->getMaterialRenderer(depth_shader_entities)->grab();
590 if (mixcsm_shader == -1) {
591 std::string depth_shader_vs = getShaderPath("shadow_shaders", "pass2_vertex.glsl");
592 if (depth_shader_vs.empty()) {
593 m_shadows_supported = false;
594 errorstream << "Error cascade shadow mapping fs shader not found." << std::endl;
598 std::string depth_shader_fs = getShaderPath("shadow_shaders", "pass2_fragment.glsl");
599 if (depth_shader_fs.empty()) {
600 m_shadows_supported = false;
601 errorstream << "Error cascade shadow mapping fs shader not found." << std::endl;
604 m_shadow_mix_cb = new shadowScreenQuadCB();
605 m_screen_quad = new shadowScreenQuad();
606 mixcsm_shader = gpu->addHighLevelShaderMaterial(
607 readShaderFile(depth_shader_vs).c_str(), "vertexMain",
609 readShaderFile(depth_shader_fs).c_str(), "pixelMain",
610 video::EPST_PS_1_2, m_shadow_mix_cb);
612 m_screen_quad->getMaterial().MaterialType =
613 (video::E_MATERIAL_TYPE)mixcsm_shader;
615 if (mixcsm_shader == -1) {
616 // upsi, something went wrong loading shader.
617 delete m_shadow_mix_cb;
618 delete m_screen_quad;
619 m_shadows_supported = false;
620 errorstream << "Error compiling cascade shadow mapping shader." << std::endl;
624 // HACK, TODO: investigate this better
625 // Grab the material renderer once more so minetest doesn't crash
627 m_driver->getMaterialRenderer(mixcsm_shader)->grab();
630 if (m_shadow_map_colored && depth_shader_trans == -1) {
631 std::string depth_shader_vs = getShaderPath("shadow_shaders", "pass1_trans_vertex.glsl");
632 if (depth_shader_vs.empty()) {
633 m_shadows_supported = false;
634 errorstream << "Error shadow mapping vs shader not found." << std::endl;
637 std::string depth_shader_fs = getShaderPath("shadow_shaders", "pass1_trans_fragment.glsl");
638 if (depth_shader_fs.empty()) {
639 m_shadows_supported = false;
640 errorstream << "Error shadow mapping fs shader not found." << std::endl;
643 m_shadow_depth_trans_cb = new ShadowDepthShaderCB();
645 depth_shader_trans = gpu->addHighLevelShaderMaterial(
646 readShaderFile(depth_shader_vs).c_str(), "vertexMain",
648 readShaderFile(depth_shader_fs).c_str(), "pixelMain",
649 video::EPST_PS_1_2, m_shadow_depth_trans_cb);
651 if (depth_shader_trans == -1) {
652 // upsi, something went wrong loading shader.
653 delete m_shadow_depth_trans_cb;
654 m_shadow_depth_trans_cb = nullptr;
655 m_shadow_map_colored = false;
656 m_shadows_supported = false;
657 errorstream << "Error compiling colored shadow mapping shader." << std::endl;
661 // HACK, TODO: investigate this better
662 // Grab the material renderer once more so minetest doesn't crash
664 m_driver->getMaterialRenderer(depth_shader_trans)->grab();
668 std::string ShadowRenderer::readShaderFile(const std::string &path)
671 if (m_shadow_map_colored)
672 prefix.append("#define COLORED_SHADOWS 1\n");
673 prefix.append("#line 0\n");
676 fs::ReadFile(path, content);
678 return prefix + content;