minetest/src/shader.cpp

889 lines
25 KiB
C++
Raw Normal View History

2012-03-19 02:59:12 +01:00
/*
2013-02-24 18:40:43 +01:00
Minetest
2013-02-24 19:38:45 +01:00
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
Copyright (C) 2013 Kahrl <kahrl@gmx.net>
2012-03-19 02:59:12 +01:00
This program is free software; you can redistribute it and/or modify
2013-04-11 22:32:37 +02:00
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
2012-03-19 02:59:12 +01:00
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2013-04-11 22:32:37 +02:00
GNU Lesser General Public License for more details.
2012-03-19 02:59:12 +01:00
2013-04-11 22:32:37 +02:00
You should have received a copy of the GNU Lesser General Public License along
2012-03-19 02:59:12 +01:00
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <fstream>
#include <iterator>
2012-03-19 02:59:12 +01:00
#include "shader.h"
#include "irrlichttypes_extrabloated.h"
#include "debug.h"
#include "filesys.h"
#include "util/container.h"
#include "util/thread.h"
#include "settings.h"
#include <ICameraSceneNode.h>
#include <IGPUProgrammingServices.h>
#include <IMaterialRenderer.h>
#include <IMaterialRendererServices.h>
#include <IShaderConstantSetCallBack.h>
#include "EShaderTypes.h"
#include "log.h"
#include "gamedef.h"
#include "client/tile.h"
2012-03-19 02:59:12 +01:00
/*
A cache from shader name to shader path
*/
MutexedMap<std::string, std::string> g_shadername_to_path_cache;
/*
Gets the path to a shader by first checking if the file
name_of_shader/filename
exists in shader_path and if not, using the data path.
If not found, returns "".
Utilizes a thread-safe cache.
*/
std::string getShaderPath(const std::string &name_of_shader,
const std::string &filename)
{
std::string combined = name_of_shader + DIR_DELIM + filename;
std::string fullpath = "";
/*
Check from cache
*/
bool incache = g_shadername_to_path_cache.get(combined, &fullpath);
if(incache)
return fullpath;
/*
Check from shader_path
*/
std::string shader_path = g_settings->get("shader_path");
if(shader_path != "")
{
std::string testpath = shader_path + DIR_DELIM + combined;
if(fs::PathExists(testpath))
fullpath = testpath;
}
/*
Check from default data directory
*/
if(fullpath == "")
{
std::string rel_path = std::string("client") + DIR_DELIM
+ "shaders" + DIR_DELIM
+ name_of_shader + DIR_DELIM
+ filename;
std::string testpath = porting::path_share + DIR_DELIM + rel_path;
if(fs::PathExists(testpath))
fullpath = testpath;
}
// Add to cache (also an empty result is cached)
g_shadername_to_path_cache.set(combined, fullpath);
// Finally return it
return fullpath;
}
/*
SourceShaderCache: A cache used for storing source shaders.
*/
class SourceShaderCache
{
public:
void insert(const std::string &name_of_shader, const std::string &filename,
const std::string &program, bool prefer_local)
2012-03-19 02:59:12 +01:00
{
std::string combined = name_of_shader + DIR_DELIM + filename;
// Try to use local shader instead if asked to
if(prefer_local){
std::string path = getShaderPath(name_of_shader, filename);
if(path != ""){
std::string p = readFile(path);
if(p != ""){
m_programs[combined] = p;
return;
}
}
}
m_programs[combined] = program;
}
2012-03-19 02:59:12 +01:00
std::string get(const std::string &name_of_shader,
const std::string &filename)
2012-03-19 02:59:12 +01:00
{
std::string combined = name_of_shader + DIR_DELIM + filename;
StringMap::iterator n = m_programs.find(combined);
if (n != m_programs.end())
2012-12-20 18:19:49 +01:00
return n->second;
2012-03-19 02:59:12 +01:00
return "";
}
2012-03-19 02:59:12 +01:00
// Primarily fetches from cache, secondarily tries to read from filesystem
std::string getOrLoad(const std::string &name_of_shader,
const std::string &filename)
2012-03-19 02:59:12 +01:00
{
std::string combined = name_of_shader + DIR_DELIM + filename;
StringMap::iterator n = m_programs.find(combined);
if (n != m_programs.end())
2012-12-20 18:19:49 +01:00
return n->second;
2012-03-19 02:59:12 +01:00
std::string path = getShaderPath(name_of_shader, filename);
if (path == "") {
infostream << "SourceShaderCache::getOrLoad(): No path found for \""
<< combined << "\"" << std::endl;
2012-03-19 02:59:12 +01:00
return "";
}
infostream << "SourceShaderCache::getOrLoad(): Loading path \""
<< path << "\"" << std::endl;
2012-03-19 02:59:12 +01:00
std::string p = readFile(path);
if (p != "") {
2012-03-19 02:59:12 +01:00
m_programs[combined] = p;
return p;
}
return "";
}
private:
StringMap m_programs;
2012-03-19 02:59:12 +01:00
std::string readFile(const std::string &path)
{
std::ifstream is(path.c_str(), std::ios::binary);
if(!is.is_open())
return "";
std::ostringstream tmp_os;
tmp_os << is.rdbuf();
return tmp_os.str();
}
};
2012-03-19 02:59:12 +01:00
/*
ShaderCallback: Sets constants that can be used in shaders
*/
class ShaderCallback : public video::IShaderConstantSetCallBack
{
std::vector<IShaderConstantSetter*> m_setters;
2012-03-19 02:59:12 +01:00
public:
ShaderCallback(const std::vector<IShaderConstantSetterFactory*> &factories)
{
for (u32 i = 0; i < factories.size(); ++i)
m_setters.push_back(factories[i]->create());
}
~ShaderCallback()
{
for (u32 i = 0; i < m_setters.size(); ++i)
delete m_setters[i];
}
2012-03-19 02:59:12 +01:00
virtual void OnSetConstants(video::IMaterialRendererServices *services, s32 userData)
{
video::IVideoDriver *driver = services->getVideoDriver();
sanity_check(driver != NULL);
2012-03-19 02:59:12 +01:00
bool is_highlevel = userData;
for (u32 i = 0; i < m_setters.size(); ++i)
m_setters[i]->onSetConstants(services, is_highlevel);
}
};
/*
MainShaderConstantSetter: Set basic constants required for almost everything
*/
class MainShaderConstantSetter : public IShaderConstantSetter
{
CachedVertexShaderSetting<float, 16> m_world_view_proj;
CachedVertexShaderSetting<float, 16> m_world;
public:
MainShaderConstantSetter() :
m_world_view_proj("mWorldViewProj"),
m_world("mWorld")
{}
~MainShaderConstantSetter() {}
virtual void onSetConstants(video::IMaterialRendererServices *services,
bool is_highlevel)
{
video::IVideoDriver *driver = services->getVideoDriver();
sanity_check(driver);
// Set clip matrix
2012-03-19 02:59:12 +01:00
core::matrix4 worldViewProj;
worldViewProj = driver->getTransform(video::ETS_PROJECTION);
worldViewProj *= driver->getTransform(video::ETS_VIEW);
worldViewProj *= driver->getTransform(video::ETS_WORLD);
if (is_highlevel)
m_world_view_proj.set(*reinterpret_cast<float(*)[16]>(worldViewProj.pointer()), services);
2012-03-19 02:59:12 +01:00
else
services->setVertexShaderConstant(worldViewProj.pointer(), 0, 4);
2012-03-19 02:59:12 +01:00
// Set world matrix
2012-03-19 02:59:12 +01:00
core::matrix4 world = driver->getTransform(video::ETS_WORLD);
if (is_highlevel)
m_world.set(*reinterpret_cast<float(*)[16]>(world.pointer()), services);
2012-03-19 02:59:12 +01:00
else
services->setVertexShaderConstant(world.pointer(), 4, 4);
2012-03-19 02:59:12 +01:00
}
};
class MainShaderConstantSetterFactory : public IShaderConstantSetterFactory
{
public:
virtual IShaderConstantSetter* create()
{ return new MainShaderConstantSetter(); }
};
2012-03-19 02:59:12 +01:00
/*
ShaderSource
*/
class ShaderSource : public IWritableShaderSource
2012-03-19 02:59:12 +01:00
{
public:
ShaderSource(IrrlichtDevice *device);
~ShaderSource();
/*
- If shader material specified by name is found from cache,
return the cached id.
- Otherwise generate the shader material, add to cache and return id.
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);
2012-03-19 02:59:12 +01:00
/*
If shader specified by the name pointed by the id doesn't
exist, create it, then return id.
2012-03-19 02:59:12 +01:00
Can be called from any thread. If called from some other thread
and not found in cache, the call is queued to the main thread
for processing.
*/
u32 getShader(const std::string &name,
const u8 material_type, const u8 drawtype);
ShaderInfo getShaderInfo(u32 id);
2012-03-19 02:59:12 +01:00
// Processes queued shader requests from other threads.
// Shall be called from the main thread.
void processQueue();
// 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);
// Rebuild shaders from the current set of source shaders
// Shall be called from the main thread.
void rebuildShaders();
void addShaderConstantSetterFactory(IShaderConstantSetterFactory *setter)
{
m_setter_factories.push_back(setter);
}
2012-03-19 02:59:12 +01:00
private:
// The id of the thread that is allowed to use irrlicht directly
threadid_t m_main_thread;
// The irrlicht device
IrrlichtDevice *m_device;
// Cache of source shaders
// This should be only accessed from the main thread
SourceShaderCache m_sourcecache;
// A shader id is index in this array.
// The first position contains a dummy shader.
2012-12-20 18:19:49 +01:00
std::vector<ShaderInfo> m_shaderinfo_cache;
// The former container is behind this mutex
Mutex m_shaderinfo_cache_mutex;
2012-03-19 02:59:12 +01:00
// Queued shader fetches (to be processed by the main thread)
RequestQueue<std::string, u32, u8, u8> m_get_shader_queue;
// Global constant setter factories
std::vector<IShaderConstantSetterFactory *> m_setter_factories;
// Shader callbacks
std::vector<ShaderCallback *> m_callbacks;
2012-03-19 02:59:12 +01:00
};
IWritableShaderSource* createShaderSource(IrrlichtDevice *device)
{
return new ShaderSource(device);
}
/*
Generate shader given the shader name.
*/
ShaderInfo generate_shader(std::string name,
u8 material_type, u8 drawtype,
IrrlichtDevice *device, std::vector<ShaderCallback *> &callbacks,
const std::vector<IShaderConstantSetterFactory*> &setter_factories,
2012-03-19 02:59:12 +01:00
SourceShaderCache *sourcecache);
/*
Load shader programs
*/
void load_shaders(std::string name, SourceShaderCache *sourcecache,
2013-07-07 21:53:40 +02:00
video::E_DRIVER_TYPE drivertype, bool enable_shaders,
2012-03-19 02:59:12 +01:00
std::string &vertex_program, std::string &pixel_program,
std::string &geometry_program, bool &is_highlevel);
ShaderSource::ShaderSource(IrrlichtDevice *device):
m_device(device)
{
assert(m_device); // Pre-condition
2012-03-19 02:59:12 +01:00
m_main_thread = thr_get_current_thread_id();
2012-03-19 02:59:12 +01:00
// Add a dummy ShaderInfo as the first index, named ""
m_shaderinfo_cache.push_back(ShaderInfo());
// Add main global constant setter
addShaderConstantSetterFactory(new MainShaderConstantSetterFactory());
2012-03-19 02:59:12 +01:00
}
ShaderSource::~ShaderSource()
{
for (std::vector<ShaderCallback *>::iterator iter = m_callbacks.begin();
iter != m_callbacks.end(); ++iter) {
2013-04-07 21:42:54 +02:00
delete *iter;
}
for (std::vector<IShaderConstantSetterFactory *>::iterator iter = m_setter_factories.begin();
iter != m_setter_factories.end(); ++iter) {
delete *iter;
}
2012-03-19 02:59:12 +01:00
}
u32 ShaderSource::getShader(const std::string &name,
const u8 material_type, const u8 drawtype)
2012-03-19 02:59:12 +01:00
{
/*
Get shader
*/
if (thr_is_current_thread(m_main_thread)) {
return getShaderIdDirect(name, material_type, drawtype);
2012-03-19 02:59:12 +01:00
} else {
/*errorstream<<"getShader(): Queued: name=\""<<name<<"\""<<std::endl;*/
2012-03-19 02:59:12 +01:00
// We're gonna ask the result to be put into here
static ResultQueue<std::string, u32, u8, u8> result_queue;
2012-03-19 02:59:12 +01:00
// Throw a request in
m_get_shader_queue.add(name, 0, 0, &result_queue);
/* infostream<<"Waiting for shader from main thread, name=\""
<<name<<"\""<<std::endl;*/
2012-03-19 02:59:12 +01:00
while(true) {
GetResult<std::string, u32, u8, u8>
result = result_queue.pop_frontNoEx();
if (result.key == name) {
return result.item;
}
else {
errorstream << "Got shader with invalid name: " << result.key << std::endl;
}
2012-03-19 02:59:12 +01:00
}
2012-03-19 02:59:12 +01:00
}
infostream<<"getShader(): Failed"<<std::endl;
2012-03-19 02:59:12 +01:00
return 0;
}
/*
This method generates all the shaders
*/
u32 ShaderSource::getShaderIdDirect(const std::string &name,
const u8 material_type, const u8 drawtype)
2012-03-19 02:59:12 +01:00
{
//infostream<<"getShaderIdDirect(): name=\""<<name<<"\""<<std::endl;
// Empty name means shader 0
if(name == ""){
infostream<<"getShaderIdDirect(): name is empty"<<std::endl;
return 0;
}
// Check if already have such instance
for(u32 i=0; i<m_shaderinfo_cache.size(); i++){
ShaderInfo *info = &m_shaderinfo_cache[i];
if(info->name == name && info->material_type == material_type &&
info->drawtype == drawtype)
return i;
}
2012-03-19 02:59:12 +01:00
/*
Calling only allowed from main thread
*/
if (!thr_is_current_thread(m_main_thread)) {
2012-03-19 02:59:12 +01:00
errorstream<<"ShaderSource::getShaderIdDirect() "
"called not from main thread"<<std::endl;
return 0;
}
ShaderInfo info = generate_shader(name, material_type, drawtype,
m_device, m_callbacks, m_setter_factories, &m_sourcecache);
2012-03-19 02:59:12 +01:00
/*
Add shader to caches (add dummy shaders too)
*/
MutexAutoLock lock(m_shaderinfo_cache_mutex);
2012-03-19 02:59:12 +01:00
u32 id = m_shaderinfo_cache.size();
m_shaderinfo_cache.push_back(info);
infostream<<"getShaderIdDirect(): "
<<"Returning id="<<id<<" for name \""<<name<<"\""<<std::endl;
2012-03-19 02:59:12 +01:00
return id;
}
ShaderInfo ShaderSource::getShaderInfo(u32 id)
2012-03-19 02:59:12 +01:00
{
MutexAutoLock lock(m_shaderinfo_cache_mutex);
2012-03-19 02:59:12 +01:00
if(id >= m_shaderinfo_cache.size())
return ShaderInfo();
return m_shaderinfo_cache[id];
}
void ShaderSource::processQueue()
{
2012-03-19 02:59:12 +01:00
}
void ShaderSource::insertSourceShader(const std::string &name_of_shader,
const std::string &filename, const std::string &program)
{
/*infostream<<"ShaderSource::insertSourceShader(): "
"name_of_shader=\""<<name_of_shader<<"\", "
"filename=\""<<filename<<"\""<<std::endl;*/
sanity_check(thr_is_current_thread(m_main_thread));
2012-03-19 02:59:12 +01:00
m_sourcecache.insert(name_of_shader, filename, program, true);
}
void ShaderSource::rebuildShaders()
{
MutexAutoLock lock(m_shaderinfo_cache_mutex);
2012-03-19 02:59:12 +01:00
/*// Oh well... just clear everything, they'll load sometime.
m_shaderinfo_cache.clear();
m_name_to_id.clear();*/
/*
FIXME: Old shader materials can't be deleted in Irrlicht,
or can they?
(This would be nice to do in the destructor too)
*/
// Recreate shaders
for(u32 i=0; i<m_shaderinfo_cache.size(); i++){
ShaderInfo *info = &m_shaderinfo_cache[i];
if(info->name != ""){
*info = generate_shader(info->name, info->material_type,
info->drawtype, m_device, m_callbacks,
m_setter_factories, &m_sourcecache);
}
2012-03-19 02:59:12 +01:00
}
}
ShaderInfo generate_shader(std::string name, u8 material_type, u8 drawtype,
IrrlichtDevice *device, std::vector<ShaderCallback *> &callbacks,
const std::vector<IShaderConstantSetterFactory*> &setter_factories,
2012-03-19 02:59:12 +01:00
SourceShaderCache *sourcecache)
{
ShaderInfo shaderinfo;
shaderinfo.name = name;
shaderinfo.material_type = material_type;
shaderinfo.drawtype = drawtype;
2012-03-19 02:59:12 +01:00
shaderinfo.material = video::EMT_SOLID;
switch(material_type){
case TILE_MATERIAL_BASIC:
shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
2012-03-19 02:59:12 +01:00
break;
case TILE_MATERIAL_ALPHA:
shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
break;
case TILE_MATERIAL_LIQUID_TRANSPARENT:
shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
break;
case TILE_MATERIAL_LIQUID_OPAQUE:
shaderinfo.base_material = video::EMT_SOLID;
break;
case TILE_MATERIAL_WAVING_LEAVES:
shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
break;
case TILE_MATERIAL_WAVING_PLANTS:
shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
break;
2012-03-19 02:59:12 +01:00
}
2013-07-07 21:53:40 +02:00
bool enable_shaders = g_settings->getBool("enable_shaders");
if (!enable_shaders)
2012-03-19 02:59:12 +01:00
return shaderinfo;
video::IVideoDriver* driver = device->getVideoDriver();
sanity_check(driver);
2012-03-19 02:59:12 +01:00
video::IGPUProgrammingServices *gpu = driver->getGPUProgrammingServices();
if(!gpu){
errorstream<<"generate_shader(): "
"failed to generate \""<<name<<"\", "
"GPU programming not supported."
<<std::endl;
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 != "" &&
!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 != "" &&
!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 != "" &&
!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 == "" && pixel_program == "" && geometry_program == "")
return shaderinfo;
// Create shaders header
std::string shaders_header = "#version 120\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",
2014-09-20 01:37:40 +02:00
"NDT_GLASSLIKE_FRAMED",
2014-09-27 18:16:26 +02:00
"NDT_FIRELIKE",
"NDT_GLASSLIKE_FRAMED_OPTIONAL"
};
for (int i = 0; i < 14; i++){
shaders_header += "#define ";
shaders_header += drawTypes[i];
shaders_header += " ";
shaders_header += itos(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"
};
for (int i = 0; i < 6; i++){
shaders_header += "#define ";
shaders_header += materialTypes[i];
shaders_header += " ";
shaders_header += itos(i);
shaders_header += "\n";
}
shaders_header += "#define MATERIAL_TYPE ";
shaders_header += itos(material_type);
shaders_header += "\n";
shaders_header += "#define DRAW_TYPE ";
shaders_header += itos(drawtype);
shaders_header += "\n";
if (g_settings->getBool("generate_normalmaps")) {
shaders_header += "#define GENERATE_NORMALMAPS 1\n";
} else {
shaders_header += "#define GENERATE_NORMALMAPS 0\n";
}
shaders_header += "#define NORMALMAPS_STRENGTH ";
shaders_header += ftos(g_settings->getFloat("normalmaps_strength"));
shaders_header += "\n";
float sample_step;
int smooth = (int)g_settings->getFloat("normalmaps_smooth");
switch (smooth){
case 0:
sample_step = 0.0078125; // 1.0 / 128.0
break;
case 1:
sample_step = 0.00390625; // 1.0 / 256.0
break;
case 2:
sample_step = 0.001953125; // 1.0 / 512.0
break;
default:
sample_step = 0.0078125;
break;
}
shaders_header += "#define SAMPLE_STEP ";
shaders_header += ftos(sample_step);
shaders_header += "\n";
if (g_settings->getBool("enable_bumpmapping"))
shaders_header += "#define ENABLE_BUMPMAPPING\n";
if (g_settings->getBool("enable_parallax_occlusion")){
int mode = g_settings->getFloat("parallax_occlusion_mode");
float scale = g_settings->getFloat("parallax_occlusion_scale");
float bias = g_settings->getFloat("parallax_occlusion_bias");
int iterations = g_settings->getFloat("parallax_occlusion_iterations");
shaders_header += "#define ENABLE_PARALLAX_OCCLUSION\n";
shaders_header += "#define PARALLAX_OCCLUSION_MODE ";
shaders_header += itos(mode);
shaders_header += "\n";
shaders_header += "#define PARALLAX_OCCLUSION_SCALE ";
shaders_header += ftos(scale);
shaders_header += "\n";
shaders_header += "#define PARALLAX_OCCLUSION_BIAS ";
shaders_header += ftos(bias);
shaders_header += "\n";
shaders_header += "#define PARALLAX_OCCLUSION_ITERATIONS ";
shaders_header += itos(iterations);
shaders_header += "\n";
}
shaders_header += "#define USE_NORMALMAPS ";
if (g_settings->getBool("enable_bumpmapping") || g_settings->getBool("enable_parallax_occlusion"))
shaders_header += "1\n";
else
shaders_header += "0\n";
if (g_settings->getBool("enable_waving_water")){
shaders_header += "#define ENABLE_WAVING_WATER 1\n";
shaders_header += "#define WATER_WAVE_HEIGHT ";
shaders_header += ftos(g_settings->getFloat("water_wave_height"));
shaders_header += "\n";
shaders_header += "#define WATER_WAVE_LENGTH ";
shaders_header += ftos(g_settings->getFloat("water_wave_length"));
shaders_header += "\n";
shaders_header += "#define WATER_WAVE_SPEED ";
shaders_header += ftos(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";
2016-01-25 13:33:22 +01:00
if (g_settings->getBool("tone_mapping"))
shaders_header += "#define ENABLE_TONE_MAPPING\n";
shaders_header += "#define FOG_START ";
shaders_header += ftos(rangelim(g_settings->getFloat("fog_start"), 0.0f, 0.99f));
shaders_header += "\n";
2012-03-19 02:59:12 +01:00
// 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()) {
2016-02-09 23:46:20 +01:00
vertex_program = shaders_header + vertex_program;
2012-03-19 02:59:12 +01:00
vertex_program_ptr = vertex_program.c_str();
}
if (!pixel_program.empty()) {
2016-02-09 23:46:20 +01:00
pixel_program = shaders_header + pixel_program;
2012-03-19 02:59:12 +01:00
pixel_program_ptr = pixel_program.c_str();
}
if (!geometry_program.empty()) {
geometry_program = shaders_header + geometry_program;
2012-03-19 02:59:12 +01:00
geometry_program_ptr = geometry_program.c_str();
}
ShaderCallback *cb = new ShaderCallback(setter_factories);
2012-03-19 02:59:12 +01:00
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
2016-02-11 07:22:15 +01:00
video::EPST_PS_1_2, // Pixel shader version
2012-03-19 02:59:12 +01:00
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
2012-03-19 02:59:12 +01:00
);
if(shadermat == -1){
errorstream<<"generate_shader(): "
"failed to generate \""<<name<<"\", "
"addHighLevelShaderMaterial failed."
<<std::endl;
2016-02-10 04:27:45 +01:00
dumpShaderProgram(warningstream, "Vertex", vertex_program);
dumpShaderProgram(warningstream, "Pixel", pixel_program);
dumpShaderProgram(warningstream, "Geometry", geometry_program);
delete cb;
2012-03-19 02:59:12 +01:00
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
2012-03-19 02:59:12 +01:00
0 // Userdata passed to callback
);
if(shadermat == -1){
errorstream<<"generate_shader(): "
"failed to generate \""<<name<<"\", "
"addShaderMaterial failed."
<<std::endl;
2016-02-10 04:27:45 +01:00
dumpShaderProgram(warningstream, "Vertex", vertex_program);
dumpShaderProgram(warningstream,"Pixel", pixel_program);
delete cb;
2012-03-19 02:59:12 +01:00
return shaderinfo;
}
}
callbacks.push_back(cb);
2012-03-19 02:59:12 +01:00
// 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(std::string name, SourceShaderCache *sourcecache,
2013-07-07 21:53:40 +02:00
video::E_DRIVER_TYPE drivertype, bool enable_shaders,
2012-03-19 02:59:12 +01:00
std::string &vertex_program, std::string &pixel_program,
std::string &geometry_program, bool &is_highlevel)
{
vertex_program = "";
pixel_program = "";
geometry_program = "";
is_highlevel = false;
2013-07-07 21:53:40 +02:00
if(enable_shaders){
2012-03-19 02:59:12 +01:00
// Look for high level shaders
if(drivertype == 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;
}
else if(drivertype == video::EDT_OPENGL){
// 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");
}
if(vertex_program != "" || pixel_program != "" || geometry_program != ""){
is_highlevel = true;
return;
}
}
}
2016-02-10 04:27:45 +01:00
void dumpShaderProgram(std::ostream &output_stream,
const std::string &program_type, const std::string &program)
{
output_stream << program_type << " shader program:" << std::endl <<
"----------------------------------" << std::endl;
size_t pos = 0;
size_t prev = 0;
s16 line = 1;
while ((pos = program.find("\n", prev)) != std::string::npos) {
output_stream << line++ << ": "<< program.substr(prev, pos - prev) <<
std::endl;
prev = pos + 1;
}
output_stream << line << ": " << program.substr(prev) << std::endl <<
"End of " << program_type << " shader program." << std::endl <<
" " << std::endl;
}