#include <iterator>
#include "shader.h"
#include "irrlichttypes_extrabloated.h"
+#include "irr_ptr.h"
#include "debug.h"
#include "filesys.h"
#include "util/container.h"
#include "client/tile.h"
#include "config.h"
-#if ENABLE_GLES
-#ifdef _IRR_COMPILE_WITH_OGLES1_
-#include <GLES/gl.h>
-#else
-#include <GLES2/gl2.h>
-#endif
-#else
-#ifndef __APPLE__
-#include <GL/gl.h>
-#else
-#define GL_SILENCE_DEPRECATION
-#include <OpenGL/gl.h>
-#endif
-#endif
+#include <mt_opengl.h>
/*
A cache from shader name to shader path
class ShaderCallback : public video::IShaderConstantSetCallBack
{
- std::vector<IShaderConstantSetter*> m_setters;
+ std::vector<std::unique_ptr<IShaderConstantSetter>> m_setters;
public:
- ShaderCallback(const std::vector<IShaderConstantSetterFactory *> &factories)
+ template <typename Factories>
+ ShaderCallback(const Factories &factories)
{
- for (IShaderConstantSetterFactory *factory : factories)
- m_setters.push_back(factory->create());
- }
-
- ~ShaderCallback()
- {
- for (IShaderConstantSetter *setter : m_setters)
- delete setter;
+ for (auto &&factory : factories)
+ m_setters.push_back(std::unique_ptr<IShaderConstantSetter>(factory->create()));
}
virtual void OnSetConstants(video::IMaterialRendererServices *services, s32 userData) override
video::IVideoDriver *driver = services->getVideoDriver();
sanity_check(driver != NULL);
- bool is_highlevel = userData;
-
- for (IShaderConstantSetter *setter : m_setters)
- setter->onSetConstants(services, is_highlevel);
+ for (auto &&setter : m_setters)
+ setter->onSetConstants(services);
}
virtual void OnSetMaterial(const video::SMaterial& material) override
{
- for (IShaderConstantSetter *setter : m_setters)
+ for (auto &&setter : m_setters)
setter->onSetMaterial(material);
}
};
class MainShaderConstantSetter : public IShaderConstantSetter
{
- CachedVertexShaderSetting<float, 16> m_world_view_proj;
- CachedVertexShaderSetting<float, 16> m_world;
+ CachedVertexShaderSetting<f32, 16> m_world_view_proj;
+ CachedVertexShaderSetting<f32, 16> m_world;
+
+ // Shadow-related
+ CachedPixelShaderSetting<f32, 16> m_shadow_view_proj;
+ CachedPixelShaderSetting<f32, 3> m_light_direction;
+ CachedPixelShaderSetting<f32> m_texture_res;
+ CachedPixelShaderSetting<f32> m_shadow_strength;
+ CachedPixelShaderSetting<f32> m_time_of_day;
+ CachedPixelShaderSetting<f32> m_shadowfar;
+ CachedPixelShaderSetting<s32> m_shadow_texture;
+ CachedVertexShaderSetting<f32> m_perspective_bias0_vertex;
+ CachedPixelShaderSetting<f32> m_perspective_bias0_pixel;
+ CachedVertexShaderSetting<f32> m_perspective_bias1_vertex;
+ CachedPixelShaderSetting<f32> m_perspective_bias1_pixel;
+ CachedVertexShaderSetting<f32> m_perspective_zbias_vertex;
+ CachedPixelShaderSetting<f32> m_perspective_zbias_pixel;
+
#if ENABLE_GLES
// Modelview matrix
CachedVertexShaderSetting<float, 16> m_world_view;
, m_texture("mTexture")
, m_normal("mNormal")
#endif
+ , m_shadow_view_proj("m_ShadowViewProj")
+ , m_light_direction("v_LightDirection")
+ , m_texture_res("f_textureresolution")
+ , m_shadow_strength("f_shadow_strength")
+ , m_time_of_day("f_timeofday")
+ , m_shadowfar("f_shadowfar")
+ , m_shadow_texture("ShadowMapSampler")
+ , m_perspective_bias0_vertex("xyPerspectiveBias0")
+ , m_perspective_bias0_pixel("xyPerspectiveBias0")
+ , m_perspective_bias1_vertex("xyPerspectiveBias1")
+ , m_perspective_bias1_pixel("xyPerspectiveBias1")
+ , m_perspective_zbias_vertex("zPerspectiveBias")
+ , m_perspective_zbias_pixel("zPerspectiveBias")
{}
~MainShaderConstantSetter() = default;
- virtual void onSetConstants(video::IMaterialRendererServices *services,
- bool is_highlevel)
+ virtual void onSetConstants(video::IMaterialRendererServices *services) override
{
video::IVideoDriver *driver = services->getVideoDriver();
sanity_check(driver);
// Set world matrix
core::matrix4 world = driver->getTransform(video::ETS_WORLD);
- if (is_highlevel)
- m_world.set(*reinterpret_cast<float(*)[16]>(world.pointer()), services);
- else
- services->setVertexShaderConstant(world.pointer(), 4, 4);
+ m_world.set(*reinterpret_cast<float(*)[16]>(world.pointer()), services);
// Set clip matrix
core::matrix4 worldView;
worldView = driver->getTransform(video::ETS_VIEW);
worldView *= world;
+
core::matrix4 worldViewProj;
worldViewProj = driver->getTransform(video::ETS_PROJECTION);
worldViewProj *= worldView;
- if (is_highlevel)
- m_world_view_proj.set(*reinterpret_cast<float(*)[16]>(worldViewProj.pointer()), services);
- else
- services->setVertexShaderConstant(worldViewProj.pointer(), 0, 4);
+ m_world_view_proj.set(*reinterpret_cast<float(*)[16]>(worldViewProj.pointer()), services);
#if ENABLE_GLES
- if (is_highlevel) {
- core::matrix4 texture = driver->getTransform(video::ETS_TEXTURE_0);
- m_world_view.set(*reinterpret_cast<float(*)[16]>(worldView.pointer()), services);
- m_texture.set(*reinterpret_cast<float(*)[16]>(texture.pointer()), services);
-
- core::matrix4 normal;
- worldView.getTransposed(normal);
- sanity_check(normal.makeInverse());
- float m[9] = {
- normal[0], normal[1], normal[2],
- normal[4], normal[5], normal[6],
- normal[8], normal[9], normal[10],
- };
- m_normal.set(m, services);
- }
+ core::matrix4 texture = driver->getTransform(video::ETS_TEXTURE_0);
+ m_world_view.set(*reinterpret_cast<float(*)[16]>(worldView.pointer()), services);
+ m_texture.set(*reinterpret_cast<float(*)[16]>(texture.pointer()), services);
+
+ core::matrix4 normal;
+ worldView.getTransposed(normal);
+ sanity_check(normal.makeInverse());
+ float m[9] = {
+ normal[0], normal[1], normal[2],
+ normal[4], normal[5], normal[6],
+ normal[8], normal[9], normal[10],
+ };
+ m_normal.set(m, services);
#endif
+
+ // Set uniforms for Shadow shader
+ if (ShadowRenderer *shadow = RenderingEngine::get_shadow_renderer()) {
+ const auto &light = shadow->getDirectionalLight();
+
+ core::matrix4 shadowViewProj = light.getProjectionMatrix();
+ shadowViewProj *= light.getViewMatrix();
+ m_shadow_view_proj.set(shadowViewProj.pointer(), services);
+
+ f32 v_LightDirection[3];
+ light.getDirection().getAs3Values(v_LightDirection);
+ m_light_direction.set(v_LightDirection, services);
+
+ f32 TextureResolution = light.getMapResolution();
+ m_texture_res.set(&TextureResolution, services);
+
+ f32 ShadowStrength = shadow->getShadowStrength();
+ m_shadow_strength.set(&ShadowStrength, services);
+
+ f32 timeOfDay = shadow->getTimeOfDay();
+ m_time_of_day.set(&timeOfDay, services);
+
+ f32 shadowFar = shadow->getMaxShadowFar();
+ m_shadowfar.set(&shadowFar, services);
+
+ // I dont like using this hardcoded value. maybe something like
+ // MAX_TEXTURE - 1 or somthing like that??
+ s32 TextureLayerID = 3;
+ m_shadow_texture.set(&TextureLayerID, services);
+
+ f32 bias0 = shadow->getPerspectiveBiasXY();
+ m_perspective_bias0_vertex.set(&bias0, services);
+ m_perspective_bias0_pixel.set(&bias0, services);
+ f32 bias1 = 1.0f - bias0 + 1e-5f;
+ m_perspective_bias1_vertex.set(&bias1, services);
+ m_perspective_bias1_pixel.set(&bias1, services);
+ f32 zbias = shadow->getPerspectiveBiasZ();
+ m_perspective_zbias_vertex.set(&zbias, services);
+ m_perspective_zbias_pixel.set(&zbias, services);
+ }
}
};
{
public:
ShaderSource();
- ~ShaderSource();
/*
- If shader material specified by name is found from cache,
The id 0 points to a null shader. Its material is EMT_SOLID.
*/
u32 getShaderIdDirect(const std::string &name,
- const u8 material_type, const u8 drawtype);
+ MaterialType material_type, NodeDrawType drawtype) override;
/*
If shader specified by the name pointed by the id doesn't
*/
u32 getShader(const std::string &name,
- const u8 material_type, const u8 drawtype);
+ MaterialType material_type, NodeDrawType drawtype) override;
- ShaderInfo getShaderInfo(u32 id);
+ ShaderInfo getShaderInfo(u32 id) override;
// Processes queued shader requests from other threads.
// Shall be called from the main thread.
- void processQueue();
+ void processQueue() override;
// Insert a shader program into the cache without touching the
// filesystem. Shall be called from the main thread.
void insertSourceShader(const std::string &name_of_shader,
- const std::string &filename, const std::string &program);
+ const std::string &filename, const std::string &program) override;
// Rebuild shaders from the current set of source shaders
// Shall be called from the main thread.
- void rebuildShaders();
+ void rebuildShaders() override;
- void addShaderConstantSetterFactory(IShaderConstantSetterFactory *setter)
+ void addShaderConstantSetterFactory(IShaderConstantSetterFactory *setter) override
{
- m_setter_factories.push_back(setter);
+ m_setter_factories.push_back(std::unique_ptr<IShaderConstantSetterFactory>(setter));
}
private:
RequestQueue<std::string, u32, u8, u8> m_get_shader_queue;
// Global constant setter factories
- std::vector<IShaderConstantSetterFactory *> m_setter_factories;
+ std::vector<std::unique_ptr<IShaderConstantSetterFactory>> m_setter_factories;
- // Shader callbacks
- std::vector<ShaderCallback *> m_callbacks;
+ // Generate shader given the shader name.
+ ShaderInfo generateShader(const std::string &name,
+ MaterialType material_type, NodeDrawType drawtype);
};
IWritableShaderSource *createShaderSource()
return new ShaderSource();
}
-/*
- Generate shader given the shader name.
-*/
-ShaderInfo generate_shader(const std::string &name,
- u8 material_type, u8 drawtype, std::vector<ShaderCallback *> &callbacks,
- const std::vector<IShaderConstantSetterFactory *> &setter_factories,
- SourceShaderCache *sourcecache);
-
-/*
- Load shader programs
-*/
-void load_shaders(const std::string &name, SourceShaderCache *sourcecache,
- video::E_DRIVER_TYPE drivertype, bool enable_shaders,
- std::string &vertex_program, std::string &pixel_program,
- std::string &geometry_program, bool &is_highlevel);
-
ShaderSource::ShaderSource()
{
m_main_thread = std::this_thread::get_id();
addShaderConstantSetterFactory(new MainShaderConstantSetterFactory());
}
-ShaderSource::~ShaderSource()
-{
- for (ShaderCallback *callback : m_callbacks) {
- delete callback;
- }
- for (IShaderConstantSetterFactory *setter_factorie : m_setter_factories) {
- delete setter_factorie;
- }
-}
-
u32 ShaderSource::getShader(const std::string &name,
- const u8 material_type, const u8 drawtype)
+ MaterialType material_type, NodeDrawType drawtype)
{
/*
Get shader
This method generates all the shaders
*/
u32 ShaderSource::getShaderIdDirect(const std::string &name,
- const u8 material_type, const u8 drawtype)
+ MaterialType material_type, NodeDrawType drawtype)
{
//infostream<<"getShaderIdDirect(): name=\""<<name<<"\""<<std::endl;
return 0;
}
- ShaderInfo info = generate_shader(name, material_type, drawtype,
- m_callbacks, m_setter_factories, &m_sourcecache);
+ ShaderInfo info = generateShader(name, material_type, drawtype);
/*
Add shader to caches (add dummy shaders too)
for (ShaderInfo &i : m_shaderinfo_cache) {
ShaderInfo *info = &i;
if (!info->name.empty()) {
- *info = generate_shader(info->name, info->material_type,
- info->drawtype, m_callbacks,
- m_setter_factories, &m_sourcecache);
+ *info = generateShader(info->name, info->material_type, info->drawtype);
}
}
}
-ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtype,
- std::vector<ShaderCallback *> &callbacks,
- const std::vector<IShaderConstantSetterFactory *> &setter_factories,
- SourceShaderCache *sourcecache)
+ShaderInfo ShaderSource::generateShader(const std::string &name,
+ MaterialType material_type, NodeDrawType drawtype)
{
ShaderInfo shaderinfo;
shaderinfo.name = name;
shaderinfo.material_type = material_type;
shaderinfo.drawtype = drawtype;
- shaderinfo.material = video::EMT_SOLID;
switch (material_type) {
case TILE_MATERIAL_OPAQUE:
case TILE_MATERIAL_LIQUID_OPAQUE:
shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
break;
}
+ shaderinfo.material = shaderinfo.base_material;
bool enable_shaders = g_settings->getBool("enable_shaders");
if (!enable_shaders)
return shaderinfo;
video::IVideoDriver *driver = RenderingEngine::get_video_driver();
-
- video::IGPUProgrammingServices *gpu = driver->getGPUProgrammingServices();
- if(!gpu){
- errorstream<<"generate_shader(): "
- "failed to generate \""<<name<<"\", "
- "GPU programming not supported."
- <<std::endl;
+ if (!driver->queryFeature(video::EVDF_ARB_GLSL)) {
+ errorstream << "Shaders are enabled but GLSL is not supported by the driver\n";
return shaderinfo;
}
-
- // Choose shader language depending on driver type and settings
- // Then load shaders
- std::string vertex_program;
- std::string pixel_program;
- std::string geometry_program;
- bool is_highlevel;
- load_shaders(name, sourcecache, driver->getDriverType(),
- enable_shaders, vertex_program, pixel_program,
- geometry_program, is_highlevel);
- // Check hardware/driver support
- if (!vertex_program.empty() &&
- !driver->queryFeature(video::EVDF_VERTEX_SHADER_1_1) &&
- !driver->queryFeature(video::EVDF_ARB_VERTEX_PROGRAM_1)){
- infostream<<"generate_shader(): vertex shaders disabled "
- "because of missing driver/hardware support."
- <<std::endl;
- vertex_program = "";
- }
- if (!pixel_program.empty() &&
- !driver->queryFeature(video::EVDF_PIXEL_SHADER_1_1) &&
- !driver->queryFeature(video::EVDF_ARB_FRAGMENT_PROGRAM_1)){
- infostream<<"generate_shader(): pixel shaders disabled "
- "because of missing driver/hardware support."
- <<std::endl;
- pixel_program = "";
- }
- if (!geometry_program.empty() &&
- !driver->queryFeature(video::EVDF_GEOMETRY_SHADER)){
- infostream<<"generate_shader(): geometry shaders disabled "
- "because of missing driver/hardware support."
- <<std::endl;
- geometry_program = "";
- }
-
- // If no shaders are used, don't make a separate material type
- if (vertex_program.empty() && pixel_program.empty() && geometry_program.empty())
- return shaderinfo;
+ video::IGPUProgrammingServices *gpu = driver->getGPUProgrammingServices();
// Create shaders header
bool use_gles = false;
#if ENABLE_GLES
use_gles = driver->getDriverType() == video::EDT_OGLES2;
#endif
- std::string shaders_header, vertex_header, pixel_header; // geometry shaders aren’t supported in GLES<3
+ std::stringstream shaders_header;
+ shaders_header
+ << std::noboolalpha
+ << std::showpoint // for GLSL ES
+ ;
+ std::string vertex_header, fragment_header, geometry_header;
if (use_gles) {
- shaders_header =
- "#version 100\n"
- ;
+ shaders_header << R"(
+ #version 100
+ )";
vertex_header = R"(
+ precision mediump float;
+
uniform highp mat4 mWorldView;
uniform highp mat4 mWorldViewProj;
uniform mediump mat4 mTexture;
attribute mediump vec3 inVertexNormal;
attribute mediump vec4 inVertexTangent;
attribute mediump vec4 inVertexBinormal;
- )";
- pixel_header = R"(
+ )";
+ fragment_header = R"(
precision mediump float;
- )";
+ )";
} else {
- shaders_header = R"(
+ shaders_header << R"(
#version 120
#define lowp
#define mediump
#define highp
- )";
+ )";
vertex_header = R"(
#define mWorldView gl_ModelViewMatrix
#define mWorldViewProj gl_ModelViewProjectionMatrix
#define inVertexNormal gl_Normal
#define inVertexTangent gl_MultiTexCoord1
#define inVertexBinormal gl_MultiTexCoord2
- )";
+ )";
+ }
+
+ // Since this is the first time we're using the GL bindings be extra careful.
+ // This should be removed before 5.6.0 or similar.
+ if (!GL.GetString) {
+ errorstream << "OpenGL procedures were not loaded correctly, "
+ "please open a bug report with details about your platform/OS." << std::endl;
+ abort();
}
bool use_discard = use_gles;
-#ifdef __unix__
// For renderers that should use discard instead of GL_ALPHA_TEST
- const char* gl_renderer = (const char*)glGetString(GL_RENDERER);
- if (strstr(gl_renderer, "GC7000"))
+ const char *renderer = reinterpret_cast<const char*>(GL.GetString(GL.RENDERER));
+ if (strstr(renderer, "GC7000"))
use_discard = true;
-#endif
- if (use_discard && shaderinfo.base_material != video::EMT_SOLID)
- shaders_header += "#define USE_DISCARD\n";
-
- static const char* drawTypes[] = {
- "NDT_NORMAL",
- "NDT_AIRLIKE",
- "NDT_LIQUID",
- "NDT_FLOWINGLIQUID",
- "NDT_GLASSLIKE",
- "NDT_ALLFACES",
- "NDT_ALLFACES_OPTIONAL",
- "NDT_TORCHLIKE",
- "NDT_SIGNLIKE",
- "NDT_PLANTLIKE",
- "NDT_FENCELIKE",
- "NDT_RAILLIKE",
- "NDT_NODEBOX",
- "NDT_GLASSLIKE_FRAMED",
- "NDT_FIRELIKE",
- "NDT_GLASSLIKE_FRAMED_OPTIONAL",
- "NDT_PLANTLIKE_ROOTED",
- };
-
- for (int i = 0; i < 14; i++){
- shaders_header += "#define ";
- shaders_header += drawTypes[i];
- shaders_header += " ";
- shaders_header += std::to_string(i);
- shaders_header += "\n";
- }
-
- static const char* materialTypes[] = {
- "TILE_MATERIAL_BASIC",
- "TILE_MATERIAL_ALPHA",
- "TILE_MATERIAL_LIQUID_TRANSPARENT",
- "TILE_MATERIAL_LIQUID_OPAQUE",
- "TILE_MATERIAL_WAVING_LEAVES",
- "TILE_MATERIAL_WAVING_PLANTS",
- "TILE_MATERIAL_OPAQUE",
- "TILE_MATERIAL_WAVING_LIQUID_BASIC",
- "TILE_MATERIAL_WAVING_LIQUID_TRANSPARENT",
- "TILE_MATERIAL_WAVING_LIQUID_OPAQUE",
- "TILE_MATERIAL_PLAIN",
- "TILE_MATERIAL_PLAIN_ALPHA",
- };
-
- for (int i = 0; i < 12; i++){
- shaders_header += "#define ";
- shaders_header += materialTypes[i];
- shaders_header += " ";
- shaders_header += std::to_string(i);
- shaders_header += "\n";
- }
-
- shaders_header += "#define MATERIAL_TYPE ";
- shaders_header += std::to_string(material_type);
- shaders_header += "\n";
- shaders_header += "#define DRAW_TYPE ";
- shaders_header += std::to_string(drawtype);
- shaders_header += "\n";
-
- if (g_settings->getBool("enable_waving_water")){
- shaders_header += "#define ENABLE_WAVING_WATER 1\n";
- shaders_header += "#define WATER_WAVE_HEIGHT ";
- shaders_header += std::to_string(g_settings->getFloat("water_wave_height"));
- shaders_header += "\n";
- shaders_header += "#define WATER_WAVE_LENGTH ";
- shaders_header += std::to_string(g_settings->getFloat("water_wave_length"));
- shaders_header += "\n";
- shaders_header += "#define WATER_WAVE_SPEED ";
- shaders_header += std::to_string(g_settings->getFloat("water_wave_speed"));
- shaders_header += "\n";
- } else{
- shaders_header += "#define ENABLE_WAVING_WATER 0\n";
- }
-
- shaders_header += "#define ENABLE_WAVING_LEAVES ";
- if (g_settings->getBool("enable_waving_leaves"))
- shaders_header += "1\n";
- else
- shaders_header += "0\n";
-
- shaders_header += "#define ENABLE_WAVING_PLANTS ";
- if (g_settings->getBool("enable_waving_plants"))
- shaders_header += "1\n";
- else
- shaders_header += "0\n";
-
- if (g_settings->getBool("tone_mapping"))
- shaders_header += "#define ENABLE_TONE_MAPPING\n";
-
- shaders_header += "#define FOG_START ";
- shaders_header += std::to_string(rangelim(g_settings->getFloat("fog_start"), 0.0f, 0.99f));
- shaders_header += "\n";
-
- // Call addHighLevelShaderMaterial() or addShaderMaterial()
- const c8* vertex_program_ptr = 0;
- const c8* pixel_program_ptr = 0;
- const c8* geometry_program_ptr = 0;
- if (!vertex_program.empty()) {
- vertex_program = shaders_header + vertex_header + vertex_program;
- vertex_program_ptr = vertex_program.c_str();
- }
- if (!pixel_program.empty()) {
- pixel_program = shaders_header + pixel_header + pixel_program;
- pixel_program_ptr = pixel_program.c_str();
- }
- if (!geometry_program.empty()) {
- geometry_program = shaders_header + geometry_program;
- geometry_program_ptr = geometry_program.c_str();
- }
- ShaderCallback *cb = new ShaderCallback(setter_factories);
- s32 shadermat = -1;
- if(is_highlevel){
- infostream<<"Compiling high level shaders for "<<name<<std::endl;
- shadermat = gpu->addHighLevelShaderMaterial(
- vertex_program_ptr, // Vertex shader program
- "vertexMain", // Vertex shader entry point
- video::EVST_VS_1_1, // Vertex shader version
- pixel_program_ptr, // Pixel shader program
- "pixelMain", // Pixel shader entry point
- video::EPST_PS_1_2, // Pixel shader version
- geometry_program_ptr, // Geometry shader program
- "geometryMain", // Geometry shader entry point
- video::EGST_GS_4_0, // Geometry shader version
- scene::EPT_TRIANGLES, // Geometry shader input
- scene::EPT_TRIANGLE_STRIP, // Geometry shader output
- 0, // Support maximum number of vertices
- cb, // Set-constant callback
- shaderinfo.base_material, // Base material
- 1 // Userdata passed to callback
- );
- if(shadermat == -1){
- errorstream<<"generate_shader(): "
- "failed to generate \""<<name<<"\", "
- "addHighLevelShaderMaterial failed."
- <<std::endl;
- dumpShaderProgram(warningstream, "Vertex", vertex_program);
- dumpShaderProgram(warningstream, "Pixel", pixel_program);
- dumpShaderProgram(warningstream, "Geometry", geometry_program);
- delete cb;
- return shaderinfo;
- }
- }
- else{
- infostream<<"Compiling assembly shaders for "<<name<<std::endl;
- shadermat = gpu->addShaderMaterial(
- vertex_program_ptr, // Vertex shader program
- pixel_program_ptr, // Pixel shader program
- cb, // Set-constant callback
- shaderinfo.base_material, // Base material
- 0 // Userdata passed to callback
- );
-
- if(shadermat == -1){
- errorstream<<"generate_shader(): "
- "failed to generate \""<<name<<"\", "
- "addShaderMaterial failed."
- <<std::endl;
- dumpShaderProgram(warningstream, "Vertex", vertex_program);
- dumpShaderProgram(warningstream,"Pixel", pixel_program);
- delete cb;
- return shaderinfo;
- }
+ if (use_discard) {
+ if (shaderinfo.base_material == video::EMT_TRANSPARENT_ALPHA_CHANNEL)
+ shaders_header << "#define USE_DISCARD 1\n";
+ else if (shaderinfo.base_material == video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF)
+ shaders_header << "#define USE_DISCARD_REF 1\n";
+ }
+
+#define PROVIDE(constant) shaders_header << "#define " #constant " " << (int)constant << "\n"
+
+ PROVIDE(NDT_NORMAL);
+ PROVIDE(NDT_AIRLIKE);
+ PROVIDE(NDT_LIQUID);
+ PROVIDE(NDT_FLOWINGLIQUID);
+ PROVIDE(NDT_GLASSLIKE);
+ PROVIDE(NDT_ALLFACES);
+ PROVIDE(NDT_ALLFACES_OPTIONAL);
+ PROVIDE(NDT_TORCHLIKE);
+ PROVIDE(NDT_SIGNLIKE);
+ PROVIDE(NDT_PLANTLIKE);
+ PROVIDE(NDT_FENCELIKE);
+ PROVIDE(NDT_RAILLIKE);
+ PROVIDE(NDT_NODEBOX);
+ PROVIDE(NDT_GLASSLIKE_FRAMED);
+ PROVIDE(NDT_FIRELIKE);
+ PROVIDE(NDT_GLASSLIKE_FRAMED_OPTIONAL);
+ PROVIDE(NDT_PLANTLIKE_ROOTED);
+
+ PROVIDE(TILE_MATERIAL_BASIC);
+ PROVIDE(TILE_MATERIAL_ALPHA);
+ PROVIDE(TILE_MATERIAL_LIQUID_TRANSPARENT);
+ PROVIDE(TILE_MATERIAL_LIQUID_OPAQUE);
+ PROVIDE(TILE_MATERIAL_WAVING_LEAVES);
+ PROVIDE(TILE_MATERIAL_WAVING_PLANTS);
+ PROVIDE(TILE_MATERIAL_OPAQUE);
+ PROVIDE(TILE_MATERIAL_WAVING_LIQUID_BASIC);
+ PROVIDE(TILE_MATERIAL_WAVING_LIQUID_TRANSPARENT);
+ PROVIDE(TILE_MATERIAL_WAVING_LIQUID_OPAQUE);
+ PROVIDE(TILE_MATERIAL_PLAIN);
+ PROVIDE(TILE_MATERIAL_PLAIN_ALPHA);
+
+#undef PROVIDE
+
+ shaders_header << "#define MATERIAL_TYPE " << (int)material_type << "\n";
+ shaders_header << "#define DRAW_TYPE " << (int)drawtype << "\n";
+
+ bool enable_waving_water = g_settings->getBool("enable_waving_water");
+ shaders_header << "#define ENABLE_WAVING_WATER " << enable_waving_water << "\n";
+ if (enable_waving_water) {
+ shaders_header << "#define WATER_WAVE_HEIGHT " << g_settings->getFloat("water_wave_height") << "\n";
+ shaders_header << "#define WATER_WAVE_LENGTH " << g_settings->getFloat("water_wave_length") << "\n";
+ shaders_header << "#define WATER_WAVE_SPEED " << g_settings->getFloat("water_wave_speed") << "\n";
+ }
+
+ shaders_header << "#define ENABLE_WAVING_LEAVES " << g_settings->getBool("enable_waving_leaves") << "\n";
+ shaders_header << "#define ENABLE_WAVING_PLANTS " << g_settings->getBool("enable_waving_plants") << "\n";
+ shaders_header << "#define ENABLE_TONE_MAPPING " << g_settings->getBool("tone_mapping") << "\n";
+
+ shaders_header << "#define FOG_START " << core::clamp(g_settings->getFloat("fog_start"), 0.0f, 0.99f) << "\n";
+
+ if (g_settings->getBool("enable_dynamic_shadows")) {
+ shaders_header << "#define ENABLE_DYNAMIC_SHADOWS 1\n";
+ if (g_settings->getBool("shadow_map_color"))
+ shaders_header << "#define COLORED_SHADOWS 1\n";
+
+ if (g_settings->getBool("shadow_poisson_filter"))
+ shaders_header << "#define POISSON_FILTER 1\n";
+
+ s32 shadow_filter = g_settings->getS32("shadow_filters");
+ shaders_header << "#define SHADOW_FILTER " << shadow_filter << "\n";
+
+ float shadow_soft_radius = g_settings->getFloat("shadow_soft_radius");
+ if (shadow_soft_radius < 1.0f)
+ shadow_soft_radius = 1.0f;
+ shaders_header << "#define SOFTSHADOWRADIUS " << shadow_soft_radius << "\n";
+ }
+
+ std::string common_header = shaders_header.str();
+
+ std::string vertex_shader = m_sourcecache.getOrLoad(name, "opengl_vertex.glsl");
+ std::string fragment_shader = m_sourcecache.getOrLoad(name, "opengl_fragment.glsl");
+ std::string geometry_shader = m_sourcecache.getOrLoad(name, "opengl_geometry.glsl");
+
+ vertex_shader = common_header + vertex_header + vertex_shader;
+ fragment_shader = common_header + fragment_header + fragment_shader;
+ const char *geometry_shader_ptr = nullptr; // optional
+ if (!geometry_shader.empty()) {
+ geometry_shader = common_header + geometry_header + geometry_shader;
+ geometry_shader_ptr = geometry_shader.c_str();
+ }
+
+ irr_ptr<ShaderCallback> cb{new ShaderCallback(m_setter_factories)};
+ infostream<<"Compiling high level shaders for "<<name<<std::endl;
+ s32 shadermat = gpu->addHighLevelShaderMaterial(
+ vertex_shader.c_str(), nullptr, video::EVST_VS_1_1,
+ fragment_shader.c_str(), nullptr, video::EPST_PS_1_1,
+ geometry_shader_ptr, nullptr, video::EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLES, 0,
+ cb.get(), shaderinfo.base_material, 1);
+ if (shadermat == -1) {
+ errorstream<<"generate_shader(): "
+ "failed to generate \""<<name<<"\", "
+ "addHighLevelShaderMaterial failed."
+ <<std::endl;
+ dumpShaderProgram(warningstream, "Vertex", vertex_shader);
+ dumpShaderProgram(warningstream, "Fragment", fragment_shader);
+ dumpShaderProgram(warningstream, "Geometry", geometry_shader);
+ return shaderinfo;
}
- callbacks.push_back(cb);
-
- // HACK, TODO: investigate this better
- // Grab the material renderer once more so minetest doesn't crash on exit
- driver->getMaterialRenderer(shadermat)->grab();
// Apply the newly created material type
shaderinfo.material = (video::E_MATERIAL_TYPE) shadermat;
return shaderinfo;
}
-void load_shaders(const std::string &name, SourceShaderCache *sourcecache,
- video::E_DRIVER_TYPE drivertype, bool enable_shaders,
- std::string &vertex_program, std::string &pixel_program,
- std::string &geometry_program, bool &is_highlevel)
-{
- vertex_program = "";
- pixel_program = "";
- geometry_program = "";
- is_highlevel = false;
-
- if (!enable_shaders)
- return;
-
- // Look for high level shaders
- switch (drivertype) {
- case video::EDT_DIRECT3D9:
- // Direct3D 9: HLSL
- // (All shaders in one file)
- vertex_program = sourcecache->getOrLoad(name, "d3d9.hlsl");
- pixel_program = vertex_program;
- geometry_program = vertex_program;
- break;
-
- case video::EDT_OPENGL:
-#if ENABLE_GLES
- case video::EDT_OGLES2:
-#endif
- // OpenGL: GLSL
- vertex_program = sourcecache->getOrLoad(name, "opengl_vertex.glsl");
- pixel_program = sourcecache->getOrLoad(name, "opengl_fragment.glsl");
- geometry_program = sourcecache->getOrLoad(name, "opengl_geometry.glsl");
- break;
-
- default:
- // e.g. OpenGL ES 1 (with no shader support)
- break;
- }
- if (!vertex_program.empty() || !pixel_program.empty() || !geometry_program.empty()){
- is_highlevel = true;
- return;
- }
-}
-
void dumpShaderProgram(std::ostream &output_stream,
const std::string &program_type, const std::string &program)
{
projects / dragonfireclient.git / blobdiff