#include <IMaterialRenderer.h>
#include <IMaterialRendererServices.h>
#include <IShaderConstantSetCallBack.h>
+#include "client/renderingengine.h"
#include "EShaderTypes.h"
#include "log.h"
#include "gamedef.h"
std::vector<IShaderConstantSetter*> m_setters;
public:
- ShaderCallback(const std::vector<IShaderConstantSetterFactory*> &factories)
+ ShaderCallback(const std::vector<IShaderConstantSetterFactory *> &factories)
{
for (u32 i = 0; i < factories.size(); ++i)
m_setters.push_back(factories[i]->create());
class ShaderSource : public IWritableShaderSource
{
public:
- ShaderSource(IrrlichtDevice *device);
+ ShaderSource();
~ShaderSource();
/*
private:
// The id of the thread that is allowed to use irrlicht directly
- threadid_t m_main_thread;
- // The irrlicht device
- IrrlichtDevice *m_device;
+ std::thread::id m_main_thread;
// Cache of source shaders
// This should be only accessed from the main thread
// The first position contains a dummy shader.
std::vector<ShaderInfo> m_shaderinfo_cache;
// The former container is behind this mutex
- Mutex m_shaderinfo_cache_mutex;
+ std::mutex m_shaderinfo_cache_mutex;
// Queued shader fetches (to be processed by the main thread)
RequestQueue<std::string, u32, u8, u8> m_get_shader_queue;
std::vector<ShaderCallback *> m_callbacks;
};
-IWritableShaderSource* createShaderSource(IrrlichtDevice *device)
+IWritableShaderSource *createShaderSource()
{
- return new ShaderSource(device);
+ return new ShaderSource();
}
/*
Generate shader given the shader name.
*/
ShaderInfo generate_shader(const std::string &name,
- u8 material_type, u8 drawtype,
- IrrlichtDevice *device, std::vector<ShaderCallback *> &callbacks,
- const std::vector<IShaderConstantSetterFactory*> &setter_factories,
+ u8 material_type, u8 drawtype, std::vector<ShaderCallback *> &callbacks,
+ const std::vector<IShaderConstantSetterFactory *> &setter_factories,
SourceShaderCache *sourcecache);
/*
std::string &vertex_program, std::string &pixel_program,
std::string &geometry_program, bool &is_highlevel);
-ShaderSource::ShaderSource(IrrlichtDevice *device):
- m_device(device)
+ShaderSource::ShaderSource()
{
- assert(m_device); // Pre-condition
-
- m_main_thread = thr_get_current_thread_id();
+ m_main_thread = std::this_thread::get_id();
// Add a dummy ShaderInfo as the first index, named ""
m_shaderinfo_cache.push_back(ShaderInfo());
Get shader
*/
- if (thr_is_current_thread(m_main_thread)) {
+ if (std::this_thread::get_id() == m_main_thread) {
return getShaderIdDirect(name, material_type, drawtype);
} else {
/*errorstream<<"getShader(): Queued: name=\""<<name<<"\""<<std::endl;*/
/*
Calling only allowed from main thread
*/
- if (!thr_is_current_thread(m_main_thread)) {
+ if (std::this_thread::get_id() != m_main_thread) {
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);
+ m_callbacks, m_setter_factories, &m_sourcecache);
/*
Add shader to caches (add dummy shaders too)
"name_of_shader=\""<<name_of_shader<<"\", "
"filename=\""<<filename<<"\""<<std::endl;*/
- sanity_check(thr_is_current_thread(m_main_thread));
+ sanity_check(std::this_thread::get_id() == m_main_thread);
m_sourcecache.insert(name_of_shader, filename, program, true);
}
ShaderInfo *info = &m_shaderinfo_cache[i];
if(info->name != ""){
*info = generate_shader(info->name, info->material_type,
- info->drawtype, m_device, m_callbacks,
+ info->drawtype, m_callbacks,
m_setter_factories, &m_sourcecache);
}
}
ShaderInfo generate_shader(const std::string &name, u8 material_type, u8 drawtype,
- IrrlichtDevice *device, std::vector<ShaderCallback *> &callbacks,
- const std::vector<IShaderConstantSetterFactory*> &setter_factories,
+ std::vector<ShaderCallback *> &callbacks,
+ const std::vector<IShaderConstantSetterFactory *> &setter_factories,
SourceShaderCache *sourcecache)
{
ShaderInfo shaderinfo;
shaderinfo.material_type = material_type;
shaderinfo.drawtype = drawtype;
shaderinfo.material = video::EMT_SOLID;
- switch(material_type){
- case TILE_MATERIAL_BASIC:
- shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- 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;
+ switch (material_type) {
+ case TILE_MATERIAL_OPAQUE:
+ case TILE_MATERIAL_LIQUID_OPAQUE:
+ shaderinfo.base_material = video::EMT_SOLID;
+ break;
+ case TILE_MATERIAL_ALPHA:
+ case TILE_MATERIAL_LIQUID_TRANSPARENT:
+ shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
+ break;
+ case TILE_MATERIAL_BASIC:
+ case TILE_MATERIAL_WAVING_LEAVES:
+ case TILE_MATERIAL_WAVING_PLANTS:
+ shaderinfo.base_material = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
break;
}
if (!enable_shaders)
return shaderinfo;
- video::IVideoDriver* driver = device->getVideoDriver();
- sanity_check(driver);
+ video::IVideoDriver *driver = RenderingEngine::get_video_driver();
video::IGPUProgrammingServices *gpu = driver->getGPUProgrammingServices();
if(!gpu){
"NDT_NODEBOX",
"NDT_GLASSLIKE_FRAMED",
"NDT_FIRELIKE",
- "NDT_GLASSLIKE_FRAMED_OPTIONAL"
+ "NDT_GLASSLIKE_FRAMED_OPTIONAL",
+ "NDT_PLANTLIKE_ROOTED",
};
for (int i = 0; i < 14; i++){
"TILE_MATERIAL_LIQUID_TRANSPARENT",
"TILE_MATERIAL_LIQUID_OPAQUE",
"TILE_MATERIAL_WAVING_LEAVES",
- "TILE_MATERIAL_WAVING_PLANTS"
+ "TILE_MATERIAL_WAVING_PLANTS",
+ "TILE_MATERIAL_OPAQUE"
};
- for (int i = 0; i < 6; i++){
+ for (int i = 0; i < 7; i++){
shaders_header += "#define ";
shaders_header += materialTypes[i];
shaders_header += " ";