aboutsummaryrefslogtreecommitdiff
path: root/src/client/shader.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/client/shader.cpp')
-rw-r--r--src/client/shader.cpp381
1 files changed, 191 insertions, 190 deletions
diff --git a/src/client/shader.cpp b/src/client/shader.cpp
index 9e0b73696..ee6079f7a 100644
--- a/src/client/shader.cpp
+++ b/src/client/shader.cpp
@@ -52,7 +52,8 @@ MutexedMap<std::string, std::string> g_shadername_to_path_cache;
Utilizes a thread-safe cache.
*/
-std::string getShaderPath(const std::string &name_of_shader, const std::string &filename)
+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;
@@ -60,7 +61,7 @@ std::string getShaderPath(const std::string &name_of_shader, const std::string &
Check from cache
*/
bool incache = g_shadername_to_path_cache.get(combined, &fullpath);
- if (incache)
+ if(incache)
return fullpath;
/*
@@ -69,7 +70,7 @@ std::string getShaderPath(const std::string &name_of_shader, const std::string &
std::string shader_path = g_settings->get("shader_path");
if (!shader_path.empty()) {
std::string testpath = shader_path + DIR_DELIM + combined;
- if (fs::PathExists(testpath))
+ if(fs::PathExists(testpath))
fullpath = testpath;
}
@@ -77,10 +78,12 @@ std::string getShaderPath(const std::string &name_of_shader, const std::string &
Check from default data directory
*/
if (fullpath.empty()) {
- std::string rel_path = std::string("client") + DIR_DELIM + "shaders" +
- DIR_DELIM + name_of_shader + DIR_DELIM + filename;
+ 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))
+ if(fs::PathExists(testpath))
fullpath = testpath;
}
@@ -99,13 +102,13 @@ class SourceShaderCache
{
public:
void insert(const std::string &name_of_shader, const std::string &filename,
- const std::string &program, bool prefer_local)
+ 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) {
+ if(prefer_local){
std::string path = getShaderPath(name_of_shader, filename);
- if (!path.empty()) {
+ if(!path.empty()){
std::string p = readFile(path);
if (!p.empty()) {
m_programs[combined] = p;
@@ -116,7 +119,8 @@ public:
m_programs[combined] = program;
}
- std::string get(const std::string &name_of_shader, const std::string &filename)
+ std::string get(const std::string &name_of_shader,
+ const std::string &filename)
{
std::string combined = name_of_shader + DIR_DELIM + filename;
StringMap::iterator n = m_programs.find(combined);
@@ -126,8 +130,8 @@ public:
}
// 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 getOrLoad(const std::string &name_of_shader,
+ const std::string &filename)
{
std::string combined = name_of_shader + DIR_DELIM + filename;
StringMap::iterator n = m_programs.find(combined);
@@ -135,13 +139,12 @@ public:
return n->second;
std::string path = getShaderPath(name_of_shader, filename);
if (path.empty()) {
- infostream << "SourceShaderCache::getOrLoad(): No path found for "
- "\""
- << combined << "\"" << std::endl;
+ infostream << "SourceShaderCache::getOrLoad(): No path found for \""
+ << combined << "\"" << std::endl;
return "";
}
- infostream << "SourceShaderCache::getOrLoad(): Loading path \"" << path
- << "\"" << std::endl;
+ infostream << "SourceShaderCache::getOrLoad(): Loading path \""
+ << path << "\"" << std::endl;
std::string p = readFile(path);
if (!p.empty()) {
m_programs[combined] = p;
@@ -149,14 +152,13 @@ public:
}
return "";
}
-
private:
StringMap m_programs;
std::string readFile(const std::string &path)
{
std::ifstream is(path.c_str(), std::ios::binary);
- if (!is.is_open())
+ if(!is.is_open())
return "";
std::ostringstream tmp_os;
tmp_os << is.rdbuf();
@@ -164,13 +166,14 @@ private:
}
};
+
/*
ShaderCallback: Sets constants that can be used in shaders
*/
class ShaderCallback : public video::IShaderConstantSetCallBack
{
- std::vector<IShaderConstantSetter *> m_setters;
+ std::vector<IShaderConstantSetter*> m_setters;
public:
ShaderCallback(const std::vector<IShaderConstantSetterFactory *> &factories)
@@ -185,8 +188,7 @@ public:
delete setter;
}
- virtual void OnSetConstants(
- video::IMaterialRendererServices *services, s32 userData) override
+ virtual void OnSetConstants(video::IMaterialRendererServices *services, s32 userData) override
{
video::IVideoDriver *driver = services->getVideoDriver();
sanity_check(driver != NULL);
@@ -197,13 +199,14 @@ public:
setter->onSetConstants(services, is_highlevel);
}
- virtual void OnSetMaterial(const video::SMaterial &material) override
+ virtual void OnSetMaterial(const video::SMaterial& material) override
{
for (IShaderConstantSetter *setter : m_setters)
setter->onSetMaterial(material);
}
};
+
/*
MainShaderConstantSetter: Set basic constants required for almost everything
*/
@@ -215,13 +218,13 @@ class MainShaderConstantSetter : public IShaderConstantSetter
public:
MainShaderConstantSetter() :
- m_world_view_proj("mWorldViewProj"), m_world("mWorld")
- {
- }
+ m_world_view_proj("mWorldViewProj"),
+ m_world("mWorld")
+ {}
~MainShaderConstantSetter() = default;
- virtual void onSetConstants(
- video::IMaterialRendererServices *services, bool is_highlevel)
+ virtual void onSetConstants(video::IMaterialRendererServices *services,
+ bool is_highlevel)
{
video::IVideoDriver *driver = services->getVideoDriver();
sanity_check(driver);
@@ -232,28 +235,29 @@ public:
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);
+ m_world_view_proj.set(*reinterpret_cast<float(*)[16]>(worldViewProj.pointer()), services);
else
services->setVertexShaderConstant(worldViewProj.pointer(), 0, 4);
// Set world matrix
core::matrix4 world = driver->getTransform(video::ETS_WORLD);
if (is_highlevel)
- m_world.set(*reinterpret_cast<float(*)[16]>(world.pointer()),
- services);
+ m_world.set(*reinterpret_cast<float(*)[16]>(world.pointer()), services);
else
services->setVertexShaderConstant(world.pointer(), 4, 4);
+
}
};
+
class MainShaderConstantSetterFactory : public IShaderConstantSetterFactory
{
public:
- virtual IShaderConstantSetter *create() { return new MainShaderConstantSetter(); }
+ virtual IShaderConstantSetter* create()
+ { return new MainShaderConstantSetter(); }
};
+
/*
ShaderSource
*/
@@ -271,8 +275,8 @@ public:
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);
+ u32 getShaderIdDirect(const std::string &name,
+ const u8 material_type, const u8 drawtype);
/*
If shader specified by the name pointed by the id doesn't
@@ -283,7 +287,8 @@ public:
for processing.
*/
- u32 getShader(const std::string &name, const u8 material_type, const u8 drawtype);
+ u32 getShader(const std::string &name,
+ const u8 material_type, const u8 drawtype);
ShaderInfo getShaderInfo(u32 id);
@@ -294,7 +299,7 @@ public:
// 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);
// Rebuild shaders from the current set of source shaders
// Shall be called from the main thread.
@@ -306,6 +311,7 @@ public:
}
private:
+
// The id of the thread that is allowed to use irrlicht directly
std::thread::id m_main_thread;
@@ -337,8 +343,8 @@ IWritableShaderSource *createShaderSource()
/*
Generate shader given the shader name.
*/
-ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtype,
- std::vector<ShaderCallback *> &callbacks,
+ShaderInfo generate_shader(const std::string &name,
+ u8 material_type, u8 drawtype, std::vector<ShaderCallback *> &callbacks,
const std::vector<IShaderConstantSetterFactory *> &setter_factories,
SourceShaderCache *sourcecache);
@@ -371,8 +377,8 @@ ShaderSource::~ShaderSource()
}
}
-u32 ShaderSource::getShader(
- const std::string &name, const u8 material_type, const u8 drawtype)
+u32 ShaderSource::getShader(const std::string &name,
+ const u8 material_type, const u8 drawtype)
{
/*
Get shader
@@ -394,15 +400,15 @@ u32 ShaderSource::getShader(
/* infostream<<"Waiting for shader from main thread, name=\""
<<name<<"\""<<std::endl;*/
- while (true) {
- GetResult<std::string, u32, u8, u8> result = result_queue.pop_frontNoEx();
+ while(true) {
+ GetResult<std::string, u32, u8, u8>
+ result = result_queue.pop_frontNoEx();
if (result.key == name) {
return result.item;
}
- errorstream << "Got shader with invalid name: " << result.key
- << std::endl;
+ errorstream << "Got shader with invalid name: " << result.key << std::endl;
}
infostream << "getShader(): Failed" << std::endl;
@@ -413,22 +419,22 @@ u32 ShaderSource::getShader(
/*
This method generates all the shaders
*/
-u32 ShaderSource::getShaderIdDirect(
- const std::string &name, const u8 material_type, const u8 drawtype)
+u32 ShaderSource::getShaderIdDirect(const std::string &name,
+ const u8 material_type, const u8 drawtype)
{
- // infostream<<"getShaderIdDirect(): name=\""<<name<<"\""<<std::endl;
+ //infostream<<"getShaderIdDirect(): name=\""<<name<<"\""<<std::endl;
// Empty name means shader 0
if (name.empty()) {
- infostream << "getShaderIdDirect(): name is empty" << std::endl;
+ 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++) {
+ 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)
+ if(info->name == name && info->material_type == material_type &&
+ info->drawtype == drawtype)
return i;
}
@@ -436,14 +442,13 @@ u32 ShaderSource::getShaderIdDirect(
Calling only allowed from main thread
*/
if (std::this_thread::get_id() != m_main_thread) {
- errorstream << "ShaderSource::getShaderIdDirect() "
- "called not from main thread"
- << std::endl;
+ errorstream<<"ShaderSource::getShaderIdDirect() "
+ "called not from main thread"<<std::endl;
return 0;
}
- ShaderInfo info = generate_shader(name, material_type, drawtype, m_callbacks,
- m_setter_factories, &m_sourcecache);
+ ShaderInfo info = generate_shader(name, material_type, drawtype,
+ m_callbacks, m_setter_factories, &m_sourcecache);
/*
Add shader to caches (add dummy shaders too)
@@ -454,18 +459,18 @@ u32 ShaderSource::getShaderIdDirect(
u32 id = m_shaderinfo_cache.size();
m_shaderinfo_cache.push_back(info);
- infostream << "getShaderIdDirect(): "
- << "Returning id=" << id << " for name \"" << name << "\""
- << std::endl;
+ infostream<<"getShaderIdDirect(): "
+ <<"Returning id="<<id<<" for name \""<<name<<"\""<<std::endl;
return id;
}
+
ShaderInfo ShaderSource::getShaderInfo(u32 id)
{
MutexAutoLock lock(m_shaderinfo_cache_mutex);
- if (id >= m_shaderinfo_cache.size())
+ if(id >= m_shaderinfo_cache.size())
return ShaderInfo();
return m_shaderinfo_cache[id];
@@ -473,6 +478,8 @@ ShaderInfo ShaderSource::getShaderInfo(u32 id)
void ShaderSource::processQueue()
{
+
+
}
void ShaderSource::insertSourceShader(const std::string &name_of_shader,
@@ -506,12 +513,13 @@ void ShaderSource::rebuildShaders()
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->drawtype, m_callbacks,
+ m_setter_factories, &m_sourcecache);
}
}
}
+
ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtype,
std::vector<ShaderCallback *> &callbacks,
const std::vector<IShaderConstantSetterFactory *> &setter_factories,
@@ -550,13 +558,11 @@ ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtyp
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(!gpu){
+ errorstream<<"generate_shader(): "
+ "failed to generate \""<<name<<"\", "
+ "GPU programming not supported."
+ <<std::endl;
return shaderinfo;
}
@@ -566,30 +572,31 @@ ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtyp
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);
+ 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;
+ !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;
+ !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;
+ !driver->queryFeature(video::EVDF_GEOMETRY_SHADER)){
+ infostream<<"generate_shader(): geometry shaders disabled "
+ "because of missing driver/hardware support."
+ <<std::endl;
geometry_program = "";
}
@@ -600,27 +607,27 @@ ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtyp
// 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",
- "NDT_GLASSLIKE_FRAMED",
- "NDT_FIRELIKE",
- "NDT_GLASSLIKE_FRAMED_OPTIONAL",
- "NDT_PLANTLIKE_ROOTED",
+ 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++) {
+ for (int i = 0; i < 14; i++){
shaders_header += "#define ";
shaders_header += drawTypes[i];
shaders_header += " ";
@@ -628,22 +635,22 @@ ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtyp
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",
+ 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++) {
+ for (int i = 0; i < 12; i++){
shaders_header += "#define ";
shaders_header += materialTypes[i];
shaders_header += " ";
@@ -668,7 +675,7 @@ ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtyp
shaders_header += "\n";
float sample_step;
int smooth = (int)g_settings->getFloat("normalmaps_smooth");
- switch (smooth) {
+ switch (smooth){
case 0:
sample_step = 0.0078125; // 1.0 / 128.0
break;
@@ -689,7 +696,7 @@ ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtyp
if (g_settings->getBool("enable_bumpmapping"))
shaders_header += "#define ENABLE_BUMPMAPPING\n";
- if (g_settings->getBool("enable_parallax_occlusion")) {
+ 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");
@@ -710,13 +717,12 @@ ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtyp
}
shaders_header += "#define USE_NORMALMAPS ";
- if (g_settings->getBool("enable_bumpmapping") ||
- g_settings->getBool("enable_parallax_occlusion"))
+ 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")) {
+ 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"));
@@ -727,7 +733,7 @@ ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtyp
shaders_header += "#define WATER_WAVE_SPEED ";
shaders_header += ftos(g_settings->getFloat("water_wave_speed"));
shaders_header += "\n";
- } else {
+ } else{
shaders_header += "#define ENABLE_WAVING_WATER 0\n";
}
@@ -751,9 +757,9 @@ ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtyp
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;
+ 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_program;
vertex_program_ptr = vertex_program.c_str();
@@ -768,57 +774,54 @@ ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtyp
}
ShaderCallback *cb = new ShaderCallback(setter_factories);
s32 shadermat = -1;
- if (is_highlevel) {
- infostream << "Compiling high level shaders for " << name << std::endl;
+ 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;
+ 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;
+ }
+ 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;
+ 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);
+ dumpShaderProgram(warningstream,"Pixel", pixel_program);
delete cb;
return shaderinfo;
}
@@ -830,7 +833,7 @@ ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtyp
driver->getMaterialRenderer(shadermat)->grab();
// Apply the newly created material type
- shaderinfo.material = (video::E_MATERIAL_TYPE)shadermat;
+ shaderinfo.material = (video::E_MATERIAL_TYPE) shadermat;
return shaderinfo;
}
@@ -844,45 +847,43 @@ void load_shaders(const std::string &name, SourceShaderCache *sourcecache,
geometry_program = "";
is_highlevel = false;
- if (enable_shaders) {
+ if(enable_shaders){
// Look for high level shaders
- if (drivertype == video::EDT_DIRECT3D9) {
+ 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) {
+ }
+ 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");
+ 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.empty() || !pixel_program.empty() ||
- !geometry_program.empty()) {
+ 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)
+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;
+ 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;
+ 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;
+ output_stream << line << ": " << program.substr(prev) << std::endl <<
+ "End of " << program_type << " shader program." << std::endl <<
+ " " << std::endl;
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-07-20 21:00:09 +0000