src/client/shadows/dynamicshadowsrender.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2021 Liso <anlismon@gmail.com>
   4
   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.
   9
  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.
  14
  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.
  18 */
  19
  20 #include <cstring>
  21 #include <cmath>
  22 #include "client/shadows/dynamicshadowsrender.h"
  23 #include "client/shadows/shadowsScreenQuad.h"
  24 #include "client/shadows/shadowsshadercallbacks.h"
  25 #include "settings.h"
  26 #include "filesys.h"
  27 #include "util/string.h"
  28 #include "client/shader.h"
  29 #include "client/client.h"
  30 #include "client/clientmap.h"
  31 #include "profiler.h"
  32
  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)
  37 {
  38         (void) m_client;
  39
  40         m_shadows_supported = true; // assume shadows supported. We will check actual support in initialize
  41         m_shadows_enabled = true;
  42
  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);
  47
  48         m_shadow_map_max_distance = g_settings->getFloat("shadow_map_max_distance");
  49
  50         m_shadow_map_texture_size = g_settings->getFloat("shadow_map_texture_size");
  51
  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");
  56 }
  57
  58 ShadowRenderer::~ShadowRenderer()
  59 {
  60         // call to disable releases dynamically allocated resources
  61         disable();
  62
  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;
  69         if (m_shadow_mix_cb)
  70                 delete m_shadow_mix_cb;
  71         m_shadow_node_array.clear();
  72         m_light_list.clear();
  73
  74         if (shadowMapTextureDynamicObjects)
  75                 m_driver->removeTexture(shadowMapTextureDynamicObjects);
  76
  77         if (shadowMapTextureFinal)
  78                 m_driver->removeTexture(shadowMapTextureFinal);
  79
  80         if (shadowMapTextureColors)
  81                 m_driver->removeTexture(shadowMapTextureColors);
  82
  83         if (shadowMapClientMap)
  84                 m_driver->removeTexture(shadowMapClientMap);
  85
  86         if (shadowMapClientMapFuture)
  87                 m_driver->removeTexture(shadowMapClientMapFuture);
  88 }
  89
  90 void ShadowRenderer::disable()
  91 {
  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);
  97         }
  98 }
  99
 100 void ShadowRenderer::initialize()
 101 {
 102         auto *gpu = m_driver->getGPUProgrammingServices();
 103
 104         // we need glsl
 105         if (m_shadows_supported && gpu && m_driver->queryFeature(video::EVDF_ARB_GLSL)) {
 106                 createShaders();
 107         } else {
 108                 m_shadows_supported = false;
 109
 110                 warningstream << "Shadows: GLSL Shader not supported on this system."
 111                         << std::endl;
 112                 return;
 113         }
 114
 115         m_texture_format = m_shadow_map_texture_32bit
 116                                            ? video::ECOLOR_FORMAT::ECF_R32F
 117                                            : video::ECOLOR_FORMAT::ECF_R16F;
 118
 119         m_texture_format_color = m_shadow_map_texture_32bit
 120                                                  ? video::ECOLOR_FORMAT::ECF_G32R32F
 121                                                  : video::ECOLOR_FORMAT::ECF_G16R16F;
 122
 123         m_shadows_enabled &= m_shadows_supported;
 124 }
 125
 126
 127 size_t ShadowRenderer::addDirectionalLight()
 128 {
 129         m_light_list.emplace_back(m_shadow_map_texture_size,
 130                         v3f(0.f, 0.f, 0.f),
 131                         video::SColor(255, 255, 255, 255), m_shadow_map_max_distance);
 132         return m_light_list.size() - 1;
 133 }
 134
 135 DirectionalLight &ShadowRenderer::getDirectionalLight(u32 index)
 136 {
 137         return m_light_list[index];
 138 }
 139
 140 size_t ShadowRenderer::getDirectionalLightCount() const
 141 {
 142         return m_light_list.size();
 143 }
 144
 145 f32 ShadowRenderer::getMaxShadowFar() const
 146 {
 147         if (!m_light_list.empty()) {
 148                 float zMax = m_light_list[0].getFarValue();
 149                 return zMax;
 150         }
 151         return 0.0f;
 152 }
 153
 154 void ShadowRenderer::setShadowIntensity(float shadow_intensity)
 155 {
 156         m_shadow_strength = pow(shadow_intensity, 1.0f / m_shadow_strength_gamma);
 157         if (m_shadow_strength > 1E-2)
 158                 enable();
 159         else
 160                 disable();
 161 }
 162
 163 void ShadowRenderer::addNodeToShadowList(
 164                 scene::ISceneNode *node, E_SHADOW_MODE shadowMode)
 165 {
 166         m_shadow_node_array.emplace_back(NodeToApply(node, shadowMode));
 167 }
 168
 169 void ShadowRenderer::removeNodeFromShadowList(scene::ISceneNode *node)
 170 {
 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);
 174                         break;
 175                 } else {
 176                         ++it;
 177                 }
 178         }
 179 }
 180
 181 void ShadowRenderer::updateSMTextures()
 182 {
 183         if (!m_shadows_enabled || m_smgr->getActiveCamera() == nullptr) {
 184                 return;
 185         }
 186
 187         if (!shadowMapTextureDynamicObjects) {
 188
 189                 shadowMapTextureDynamicObjects = getSMTexture(
 190                         std::string("shadow_dynamic_") + itos(m_shadow_map_texture_size),
 191                         m_texture_format, true);
 192                 assert(shadowMapTextureDynamicObjects != nullptr);
 193         }
 194
 195         if (!shadowMapClientMap) {
 196
 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,
 200                         true);
 201                 assert(shadowMapClientMap != nullptr);
 202         }
 203
 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,
 208                         true);
 209                 assert(shadowMapClientMapFuture != nullptr);
 210         }
 211
 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,
 216                         true);
 217                 assert(shadowMapTextureColors != nullptr);
 218         }
 219
 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;
 226                         else
 227                                 frt = video::ECOLOR_FORMAT::ECF_R32F;
 228                 } else {
 229                         if (m_shadow_map_colored)
 230                                 frt = video::ECOLOR_FORMAT::ECF_A16B16G16R16F;
 231                         else
 232                                 frt = video::ECOLOR_FORMAT::ECF_R16F;
 233                 }
 234                 shadowMapTextureFinal = getSMTexture(
 235                         std::string("shadowmap_final_") + itos(m_shadow_map_texture_size),
 236                         frt, true);
 237                 assert(shadowMapTextureFinal != nullptr);
 238         }
 239
 240         if (!m_shadow_node_array.empty() && !m_light_list.empty()) {
 241                 bool reset_sm_texture = false;
 242
 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;
 247                                 m_current_frame = 0;
 248                                 reset_sm_texture = true;
 249                         }
 250                 }
 251
 252                 video::ITexture* shadowMapTargetTexture = shadowMapClientMapFuture;
 253                 if (shadowMapTargetTexture == nullptr)
 254                         shadowMapTargetTexture = shadowMapClientMap;
 255
 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})
 260                                 if (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();
 266                                 }
 267
 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
 272
 273
 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);
 278
 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));
 286                                         }
 287                                         renderShadowMap(shadowMapTextureColors, light,
 288                                                         scene::ESNRP_TRANSPARENT);
 289                                 }
 290                                 m_driver->setRenderTarget(0, false, false);
 291                         }
 292
 293                         reset_sm_texture = false;
 294                 } // end for lights
 295
 296                 // move to the next section
 297                 if (m_current_frame <= m_map_shadow_update_frames)
 298                         ++m_current_frame;
 299
 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);
 304
 305                         // Let all lights know that maps are updated
 306                         for (DirectionalLight &light : m_light_list)
 307                                 light.commitFrustum();
 308                 }
 309         }
 310 }
 311
 312 void ShadowRenderer::update(video::ITexture *outputTarget)
 313 {
 314         if (!m_shadows_enabled || m_smgr->getActiveCamera() == nullptr) {
 315                 return;
 316         }
 317
 318         updateSMTextures();
 319
 320         if (shadowMapTextureFinal == nullptr) {
 321                 return;
 322         }
 323
 324         if (!m_shadow_node_array.empty() && !m_light_list.empty()) {
 325
 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();
 331
 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);
 338
 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);
 347
 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);
 352
 353                 } // end for lights
 354         }
 355 }
 356
 357 void ShadowRenderer::drawDebug()
 358 {
 359         /* this code just shows shadows textures in screen and in ONLY for debugging*/
 360         #if 0
 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()));
 366
 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()));
 371
 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()));
 377
 378         if (m_shadow_map_colored && shadowMapTextureColors) {
 379
 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()));
 384         }
 385         #endif
 386 }
 387
 388
 389 video::ITexture *ShadowRenderer::getSMTexture(const std::string &shadow_map_name,
 390                 video::ECOLOR_FORMAT texture_format, bool force_creation)
 391 {
 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);
 397         }
 398
 399         return m_driver->getTexture(shadow_map_name.c_str());
 400 }
 401
 402 void ShadowRenderer::renderShadowMap(video::ITexture *target,
 403                 DirectionalLight &light, scene::E_SCENE_NODE_RENDER_PASS pass)
 404 {
 405         m_driver->setTransform(video::ETS_VIEW, light.getFutureViewMatrix());
 406         m_driver->setTransform(video::ETS_PROJECTION, light.getFutureProjectionMatrix());
 407
 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)
 411                         continue;
 412
 413                 ClientMap *map_node = static_cast<ClientMap *>(shadow_node.node);
 414
 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);
 419                 }
 420
 421                 material.BackfaceCulling = false;
 422                 material.FrontfaceCulling = true;
 423
 424                 if (m_shadow_map_colored && pass != scene::ESNRP_SOLID) {
 425                         material.MaterialType = (video::E_MATERIAL_TYPE) depth_shader_trans;
 426                 }
 427                 else {
 428                         material.MaterialType = (video::E_MATERIAL_TYPE) depth_shader;
 429                         material.BlendOperation = video::EBO_MIN;
 430                 }
 431
 432                 m_driver->setTransform(video::ETS_WORLD,
 433                                 map_node->getAbsoluteTransformation());
 434
 435                 map_node->renderMapShadows(m_driver, material, pass, m_current_frame, m_map_shadow_update_frames);
 436                 break;
 437         }
 438 }
 439
 440 void ShadowRenderer::renderShadowObjects(
 441                 video::ITexture *target, DirectionalLight &light)
 442 {
 443         m_driver->setTransform(video::ETS_VIEW, light.getViewMatrix());
 444         m_driver->setTransform(video::ETS_PROJECTION, light.getProjectionMatrix());
 445
 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)
 450                         continue;
 451
 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);
 460
 461                 // backup materialtype for each material
 462                 // (aka shader)
 463                 // and replace it by our "depth" shader
 464                 for (u32 m = 0; m < n_node_materials; m++) {
 465                         auto &current_mat = shadow_node.node->getMaterial(m);
 466
 467                         BufferMaterialList.push_back(current_mat.MaterialType);
 468                         current_mat.MaterialType =
 469                                         (video::E_MATERIAL_TYPE)depth_shader_entities;
 470
 471                         BufferMaterialCullingList.emplace_back(
 472                                 (bool)current_mat.BackfaceCulling, (bool)current_mat.FrontfaceCulling);
 473                         BufferBlendOperationList.push_back(current_mat.BlendOperation);
 474
 475                         current_mat.BackfaceCulling = true;
 476                         current_mat.FrontfaceCulling = false;
 477                 }
 478
 479                 m_driver->setTransform(video::ETS_WORLD,
 480                                 shadow_node.node->getAbsoluteTransformation());
 481                 shadow_node.node->render();
 482
 483                 // restore the material.
 484
 485                 for (u32 m = 0; m < n_node_materials; m++) {
 486                         auto &current_mat = shadow_node.node->getMaterial(m);
 487
 488                         current_mat.MaterialType = (video::E_MATERIAL_TYPE) BufferMaterialList[m];
 489
 490                         current_mat.BackfaceCulling = BufferMaterialCullingList[m].first;
 491                         current_mat.FrontfaceCulling = BufferMaterialCullingList[m].second;
 492                         current_mat.BlendOperation = BufferBlendOperationList[m];
 493                 }
 494
 495         } // end for caster shadow nodes
 496 }
 497
 498 void ShadowRenderer::mixShadowsQuad()
 499 {
 500 }
 501
 502 /*
 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.
 508  */
 509
 510 void ShadowRenderer::createShaders()
 511 {
 512         video::IGPUProgrammingServices *gpu = m_driver->getGPUProgrammingServices();
 513
 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;
 519                         return;
 520                 }
 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;
 525                         return;
 526                 }
 527                 m_shadow_depth_cb = new ShadowDepthShaderCB();
 528
 529                 depth_shader = gpu->addHighLevelShaderMaterial(
 530                                 readShaderFile(depth_shader_vs).c_str(), "vertexMain",
 531                                 video::EVST_VS_1_1,
 532                                 readShaderFile(depth_shader_fs).c_str(), "pixelMain",
 533                                 video::EPST_PS_1_2, m_shadow_depth_cb, video::EMT_ONETEXTURE_BLEND);
 534
 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;
 542                         return;
 543                 }
 544
 545                 // HACK, TODO: investigate this better
 546                 // Grab the material renderer once more so minetest doesn't crash
 547                 // on exit
 548                 m_driver->getMaterialRenderer(depth_shader)->grab();
 549         }
 550
 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;
 558                         return;
 559                 }
 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;
 564                         return;
 565                 }
 566                 m_shadow_depth_entity_cb = new ShadowDepthShaderCB();
 567
 568                 depth_shader_entities = gpu->addHighLevelShaderMaterial(
 569                                 readShaderFile(depth_shader_vs).c_str(), "vertexMain",
 570                                 video::EVST_VS_1_1,
 571                                 readShaderFile(depth_shader_fs).c_str(), "pixelMain",
 572                                 video::EPST_PS_1_2, m_shadow_depth_entity_cb);
 573
 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;
 581                         return;
 582                 }
 583
 584                 // HACK, TODO: investigate this better
 585                 // Grab the material renderer once more so minetest doesn't crash
 586                 // on exit
 587                 m_driver->getMaterialRenderer(depth_shader_entities)->grab();
 588         }
 589
 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;
 595                         return;
 596                 }
 597
 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;
 602                         return;
 603                 }
 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",
 608                                 video::EVST_VS_1_1,
 609                                 readShaderFile(depth_shader_fs).c_str(), "pixelMain",
 610                                 video::EPST_PS_1_2, m_shadow_mix_cb);
 611
 612                 m_screen_quad->getMaterial().MaterialType =
 613                                 (video::E_MATERIAL_TYPE)mixcsm_shader;
 614
 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;
 621                         return;
 622                 }
 623
 624                 // HACK, TODO: investigate this better
 625                 // Grab the material renderer once more so minetest doesn't crash
 626                 // on exit
 627                 m_driver->getMaterialRenderer(mixcsm_shader)->grab();
 628         }
 629
 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;
 635                         return;
 636                 }
 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;
 641                         return;
 642                 }
 643                 m_shadow_depth_trans_cb = new ShadowDepthShaderCB();
 644
 645                 depth_shader_trans = gpu->addHighLevelShaderMaterial(
 646                                 readShaderFile(depth_shader_vs).c_str(), "vertexMain",
 647                                 video::EVST_VS_1_1,
 648                                 readShaderFile(depth_shader_fs).c_str(), "pixelMain",
 649                                 video::EPST_PS_1_2, m_shadow_depth_trans_cb);
 650
 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;
 658                         return;
 659                 }
 660
 661                 // HACK, TODO: investigate this better
 662                 // Grab the material renderer once more so minetest doesn't crash
 663                 // on exit
 664                 m_driver->getMaterialRenderer(depth_shader_trans)->grab();
 665         }
 666 }
 667
 668 std::string ShadowRenderer::readShaderFile(const std::string &path)
 669 {
 670         std::string prefix;
 671         if (m_shadow_map_colored)
 672                 prefix.append("#define COLORED_SHADOWS 1\n");
 673         prefix.append("#line 0\n");
 674
 675         std::string content;
 676         fs::ReadFile(path, content);
 677
 678         return prefix + content;
 679 }