diff options
Diffstat (limited to 'src/shader.cpp')
| -rw-r--r-- | src/shader.cpp | 731 |
1 files changed, 731 insertions, 0 deletions
diff --git a/src/shader.cpp b/src/shader.cpp new file mode 100644 index 000000000..ba0b8600a --- /dev/null +++ b/src/shader.cpp @@ -0,0 +1,731 @@ +/* +Minetest-c55 +Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com> +Copyright (C) 2012 Kahrl <kahrl@gmx.net> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(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 +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#include "shader.h" +#include "irrlichttypes_extrabloated.h" +#include "debug.h" +#include "main.h" // for g_settings +#include "filesys.h" +#include "util/container.h" +#include "util/thread.h" +#include "settings.h" +#include <iterator> +#include <ICameraSceneNode.h> +#include <IGPUProgrammingServices.h> +#include <IMaterialRenderer.h> +#include <IMaterialRendererServices.h> +#include <IShaderConstantSetCallBack.h> +#include "EShaderTypes.h" +#include "log.h" +#include "gamedef.h" + +/* + 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) + { + 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; + } + std::string get(const std::string &name_of_shader, + const std::string &filename) + { + std::string combined = name_of_shader + DIR_DELIM + filename; + core::map<std::string, std::string>::Node *n; + n = m_programs.find(combined); + if(n) + return n->getValue(); + return ""; + } + // Primarily fetches from cache, secondarily tries to read from filesystem + std::string getOrLoad(const std::string &name_of_shader, + const std::string &filename) + { + std::string combined = name_of_shader + DIR_DELIM + filename; + core::map<std::string, std::string>::Node *n; + n = m_programs.find(combined); + if(n) + return n->getValue(); + std::string path = getShaderPath(name_of_shader, filename); + if(path == ""){ + infostream<<"SourceShaderCache::getOrLoad(): No path found for \"" + <<combined<<"\""<<std::endl; + return ""; + } + infostream<<"SourceShaderCache::getOrLoad(): Loading path \""<<path + <<"\""<<std::endl; + std::string p = readFile(path); + if(p != ""){ + m_programs[combined] = p; + return p; + } + return ""; + } +private: + core::map<std::string, std::string> m_programs; + 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(); + } +}; + +/* + ShaderCallback: Sets constants that can be used in shaders +*/ + +class ShaderCallback : public video::IShaderConstantSetCallBack +{ +public: + ShaderCallback(IrrlichtDevice *device): m_device(device) {} + ~ShaderCallback() {} + + virtual void OnSetConstants(video::IMaterialRendererServices *services, s32 userData) + { + video::IVideoDriver *driver = services->getVideoDriver(); + assert(driver); + + bool is_highlevel = userData; + + // set inverted world matrix + core::matrix4 invWorld = driver->getTransform(video::ETS_WORLD); + invWorld.makeInverse(); + if(is_highlevel) + services->setVertexShaderConstant("mInvWorld", invWorld.pointer(), 16); + else + services->setVertexShaderConstant(invWorld.pointer(), 0, 4); + + // set clip matrix + core::matrix4 worldViewProj; + worldViewProj = driver->getTransform(video::ETS_PROJECTION); + worldViewProj *= driver->getTransform(video::ETS_VIEW); + worldViewProj *= driver->getTransform(video::ETS_WORLD); + if(is_highlevel) + services->setVertexShaderConstant("mWorldViewProj", worldViewProj.pointer(), 16); + else + services->setVertexShaderConstant(worldViewProj.pointer(), 4, 4); + + // set transposed world matrix + core::matrix4 world = driver->getTransform(video::ETS_WORLD); + world = world.getTransposed(); + if(is_highlevel) + services->setVertexShaderConstant("mTransWorld", world.pointer(), 16); + else + services->setVertexShaderConstant(world.pointer(), 8, 4); + } + +private: + IrrlichtDevice *m_device; +}; + +/* + ShaderSource +*/ + +class ShaderSource : public IWritableShaderSource +{ +public: + ShaderSource(IrrlichtDevice *device); + ~ShaderSource(); + + /* + Gets a shader material id from cache or + - if main thread, from getShaderIdDirect + - if other thread, adds to request queue and waits for main thread + */ + u32 getShaderId(const std::string &name); + + /* + - 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); + + // Finds out the name of a cached shader. + std::string getShaderName(u32 id); + + /* + If shader specified by the name pointed by the id doesn't + exist, create it, then return the cached shader. + + 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. + */ + ShaderInfo getShader(u32 id); + + ShaderInfo getShader(const std::string &name) + { + return getShader(getShaderId(name)); + } + + // 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(); + +private: + + // The id of the thread that is allowed to use irrlicht directly + threadid_t m_main_thread; + // The irrlicht device + IrrlichtDevice *m_device; + // The set-constants callback + ShaderCallback *m_shader_callback; + + // 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. + core::array<ShaderInfo> m_shaderinfo_cache; + // Maps a shader name to an index in the former. + core::map<std::string, u32> m_name_to_id; + // The two former containers are behind this mutex + JMutex m_shaderinfo_cache_mutex; + + // Queued shader fetches (to be processed by the main thread) + RequestQueue<std::string, u32, u8, u8> m_get_shader_queue; +}; + +IWritableShaderSource* createShaderSource(IrrlichtDevice *device) +{ + return new ShaderSource(device); +} + +/* + Generate shader given the shader name. +*/ +ShaderInfo generate_shader(std::string name, IrrlichtDevice *device, + video::IShaderConstantSetCallBack *callback, + SourceShaderCache *sourcecache); + +/* + Load shader programs +*/ +void load_shaders(std::string name, SourceShaderCache *sourcecache, + video::E_DRIVER_TYPE drivertype, s32 enable_shaders, + 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); + + m_shader_callback = new ShaderCallback(device); + + m_shaderinfo_cache_mutex.Init(); + + m_main_thread = get_current_thread_id(); + + // Add a dummy ShaderInfo as the first index, named "" + m_shaderinfo_cache.push_back(ShaderInfo()); + m_name_to_id[""] = 0; +} + +ShaderSource::~ShaderSource() +{ + //m_shader_callback->drop(); +} + +u32 ShaderSource::getShaderId(const std::string &name) +{ + //infostream<<"getShaderId(): \""<<name<<"\""<<std::endl; + + { + /* + See if shader already exists + */ + JMutexAutoLock lock(m_shaderinfo_cache_mutex); + core::map<std::string, u32>::Node *n; + n = m_name_to_id.find(name); + if(n != NULL) + return n->getValue(); + } + + /* + Get shader + */ + if(get_current_thread_id() == m_main_thread){ + return getShaderIdDirect(name); + } else { + infostream<<"getShaderId(): Queued: name=\""<<name<<"\""<<std::endl; + + // We're gonna ask the result to be put into here + ResultQueue<std::string, u32, u8, u8> result_queue; + + // 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; + + try{ + // Wait result for a second + GetResult<std::string, u32, u8, u8> + result = result_queue.pop_front(1000); + + // Check that at least something worked OK + assert(result.key == name); + + return result.item; + } + catch(ItemNotFoundException &e){ + infostream<<"Waiting for shader timed out."<<std::endl; + return 0; + } + } + + infostream<<"getShaderId(): Failed"<<std::endl; + + return 0; +} + +/* + This method generates all the shaders +*/ +u32 ShaderSource::getShaderIdDirect(const std::string &name) +{ + //infostream<<"getShaderIdDirect(): name=\""<<name<<"\""<<std::endl; + + // Empty name means shader 0 + if(name == ""){ + infostream<<"getShaderIdDirect(): name is empty"<<std::endl; + return 0; + } + + /* + Calling only allowed from main thread + */ + if(get_current_thread_id() != m_main_thread){ + errorstream<<"ShaderSource::getShaderIdDirect() " + "called not from main thread"<<std::endl; + return 0; + } + + /* + See if shader already exists + */ + { + JMutexAutoLock lock(m_shaderinfo_cache_mutex); + + core::map<std::string, u32>::Node *n; + n = m_name_to_id.find(name); + if(n != NULL){ + /*infostream<<"getShaderIdDirect(): \""<<name + <<"\" found in cache"<<std::endl;*/ + return n->getValue(); + } + } + + /*infostream<<"getShaderIdDirect(): \""<<name + <<"\" NOT found in cache. Creating it."<<std::endl;*/ + + ShaderInfo info = generate_shader(name, m_device, + m_shader_callback, &m_sourcecache); + + /* + Add shader to caches (add dummy shaders too) + */ + + JMutexAutoLock lock(m_shaderinfo_cache_mutex); + + u32 id = m_shaderinfo_cache.size(); + m_shaderinfo_cache.push_back(info); + m_name_to_id.insert(name, id); + + /*infostream<<"getShaderIdDirect(): " + <<"Returning id="<<id<<" for name \""<<name<<"\""<<std::endl;*/ + + return id; +} + +std::string ShaderSource::getShaderName(u32 id) +{ + JMutexAutoLock lock(m_shaderinfo_cache_mutex); + + if(id >= m_shaderinfo_cache.size()){ + errorstream<<"ShaderSource::getShaderName(): id="<<id + <<" >= m_shaderinfo_cache.size()=" + <<m_shaderinfo_cache.size()<<std::endl; + return ""; + } + + return m_shaderinfo_cache[id].name; +} + +ShaderInfo ShaderSource::getShader(u32 id) +{ + JMutexAutoLock lock(m_shaderinfo_cache_mutex); + + if(id >= m_shaderinfo_cache.size()) + return ShaderInfo(); + + return m_shaderinfo_cache[id]; +} + +void ShaderSource::processQueue() +{ + /* + Fetch shaders + */ + if(m_get_shader_queue.size() > 0){ + GetRequest<std::string, u32, u8, u8> + request = m_get_shader_queue.pop(); + + /*infostream<<"ShaderSource::processQueue(): " + <<"got shader request with " + <<"name=\""<<request.key<<"\"" + <<std::endl;*/ + + GetResult<std::string, u32, u8, u8> + result; + result.key = request.key; + result.callers = request.callers; + result.item = getShaderIdDirect(request.key); + + request.dest->push_back(result); + } +} + +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;*/ + + assert(get_current_thread_id() == m_main_thread); + + m_sourcecache.insert(name_of_shader, filename, program, true); +} + +void ShaderSource::rebuildShaders() +{ + JMutexAutoLock lock(m_shaderinfo_cache_mutex); + + /*// 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]; + *info = generate_shader(info->name, m_device, + m_shader_callback, &m_sourcecache); + } +} + +ShaderInfo generate_shader(std::string name, IrrlichtDevice *device, + video::IShaderConstantSetCallBack *callback, + SourceShaderCache *sourcecache) +{ + /*infostream<<"generate_shader(): " + "\""<<name<<"\""<<std::endl;*/ + + ShaderInfo shaderinfo; + shaderinfo.name = name; + shaderinfo.material = video::EMT_SOLID; + + /* + Get the base material + */ + std::string base_material_name = sourcecache->getOrLoad(name, "base.txt"); + for(s32 i = 0; video::sBuiltInMaterialTypeNames[i] != 0; i++){ + if(video::sBuiltInMaterialTypeNames[i] == base_material_name){ + shaderinfo.material = (video::E_MATERIAL_TYPE) i; + break; + } + } + + // 0 = off, 1 = assembly shaders only, 2 = highlevel or assembly + s32 enable_shaders = g_settings->getS32("enable_shaders"); + if(enable_shaders <= 0) + return shaderinfo; + + video::IVideoDriver* driver = device->getVideoDriver(); + assert(driver); + + 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; + + // 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 != "") + vertex_program_ptr = vertex_program.c_str(); + if(pixel_program != "") + pixel_program_ptr = pixel_program.c_str(); + if(geometry_program != "") + geometry_program_ptr = geometry_program.c_str(); + 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_1, // 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 + callback, // Set-constant callback + shaderinfo.material, // Base material + 1 // Userdata passed to callback + ); + + if(shadermat == -1){ + errorstream<<"generate_shader(): " + "failed to generate \""<<name<<"\", " + "addHighLevelShaderMaterial failed." + <<std::endl; + 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 + callback, // Set-constant callback + shaderinfo.material, // Base material + 0 // Userdata passed to callback + ); + + if(shadermat == -1){ + errorstream<<"generate_shader(): " + "failed to generate \""<<name<<"\", " + "addShaderMaterial failed." + <<std::endl; + return shaderinfo; + } + } + + // 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, + video::E_DRIVER_TYPE drivertype, s32 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 >= 2){ + // 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; + } + } + + if(enable_shaders >= 1){ + // Look for assembly shaders + if(drivertype == video::EDT_DIRECT3D8){ + // Direct3D 8 assembly shaders + vertex_program = sourcecache->getOrLoad(name, "d3d8_vertex.asm"); + pixel_program = sourcecache->getOrLoad(name, "d3d8_pixel.asm"); + } + else if(drivertype == video::EDT_DIRECT3D9){ + // Direct3D 9 assembly shaders + vertex_program = sourcecache->getOrLoad(name, "d3d9_vertex.asm"); + pixel_program = sourcecache->getOrLoad(name, "d3d9_pixel.asm"); + } + else if(drivertype == video::EDT_OPENGL){ + // OpenGL assembly shaders + vertex_program = sourcecache->getOrLoad(name, "opengl_vertex.asm"); + pixel_program = sourcecache->getOrLoad(name, "opengl_fragment.asm"); + } + if(vertex_program != "" || pixel_program != "") + return; + } +} |