/**
* Main constructor.
*/
OpenGLRenderSystem::OpenGLRenderSystem() :
_realised(false),
_glProgramFactory(std::make_shared<GLProgramFactory>()),
_currentShaderProgram(SHADER_PROGRAM_NONE),
_time(0),
m_lightsChanged(true),
m_traverseRenderablesMutex(false)
{
// For the static default rendersystem, the MaterialManager is not existent yet,
// hence it will be attached in initialiseModule().
if (module::ModuleRegistry::Instance().moduleExists(MODULE_SHADERSYSTEM))
{
_materialDefsLoaded = GlobalMaterialManager().signal_DefsLoaded().connect(
sigc::mem_fun(*this, &OpenGLRenderSystem::realise));
_materialDefsUnloaded = GlobalMaterialManager().signal_DefsUnloaded().connect(
sigc::mem_fun(*this, &OpenGLRenderSystem::unrealise));
if (GlobalMaterialManager().isRealised())
{
realise();
}
}
// If the openGL module is already initialised and a shared context is created
// trigger a call to extensionsInitialised().
if (module::ModuleRegistry::Instance().moduleExists(MODULE_OPENGL) &&
GlobalOpenGL().wxContextValid())
{
extensionsInitialised();
}
}
void EClassManager::initialiseModule(const ApplicationContext& ctx)
{
rMessage() << "EntityClassDoom3::initialiseModule called." << std::endl;
GlobalFileSystem().addObserver(*this);
realise();
}
void refresh ()
{
if (isModified()) {
flush();
unrealise();
realise();
}
}
ModelResource (const std::string& name) :
m_model(g_nullModel), m_originalName(name), m_type(os::getExtension(name)), m_loader(0),
m_modified(0), m_unrealised(1)
{
m_loader = ModelLoader_forType(m_type);
if (g_realised) {
realise();
}
}
void EClassManager::initialiseModule(const ApplicationContext& ctx)
{
rMessage() << "EntityClassDoom3::initialiseModule called." << std::endl;
GlobalFileSystem().addObserver(*this);
realise();
GlobalCommandSystem().addCommand("ReloadDefs", boost::bind(&EClassManager::reloadDefsCmd, this, _1));
GlobalEventManager().addCommand("ReloadDefs", "ReloadDefs");
}
/* Constructor. Sets the name and the ShaderDefinition to use.
*/
CShader::CShader(const std::string& name, const ShaderDefinition& definition) :
_template(definition.shaderTemplate),
_fileName(definition.filename),
_name(name),
m_bInUse(false),
_visible(true)
{
// Realise the shader
realise();
}
void Doom3ShaderSystem::initialiseModule(const ApplicationContext& ctx)
{
rMessage() << getName() << "::initialiseModule called" << std::endl;
GlobalCommandSystem().addCommand("RefreshShaders", boost::bind(&Doom3ShaderSystem::refreshShadersCmd, this, _1));
GlobalEventManager().addCommand("RefreshShaders", "RefreshShaders");
construct();
realise();
#ifdef _DEBUG
testShaderExpressionParsing();
#endif
}
ModelResource(const CopiedString& name) :
m_model(g_nullModel),
m_originalName(name),
m_type(path_get_extension(name.c_str())),
m_loader(0),
m_modified(0),
m_unrealised(1)
{
m_loader = ModelLoader_forType(m_type.c_str());
if(g_realised)
{
realise();
}
}
void OpenGLRenderSystem::initialiseModule(const ApplicationContext& ctx)
{
rMessage() << getName() << "::initialiseModule called." << std::endl;
_materialDefsLoaded = GlobalMaterialManager().signal_DefsLoaded().connect(
sigc::mem_fun(*this, &OpenGLRenderSystem::realise));
_materialDefsUnloaded = GlobalMaterialManager().signal_DefsUnloaded().connect(
sigc::mem_fun(*this, &OpenGLRenderSystem::unrealise));
if (GlobalMaterialManager().isRealised())
{
realise();
}
// greebo: Don't realise the module yet, this must wait
// until the shared GL context has been created (this
// happens as soon as the first GL widget has been realised).
}
void OpenGLRenderSystem::setShaderProgram(RenderSystem::ShaderProgram newProg)
{
ShaderProgram oldProgram = _currentShaderProgram;
if (oldProgram != newProg)
{
unrealise();
GlobalMaterialManager().setLightingEnabled(
newProg == SHADER_PROGRAM_INTERACTION
);
}
_currentShaderProgram = newProg;
if (oldProgram != newProg)
{
realise();
}
}
void Doom3ShaderSystem::refresh() {
unrealise();
realise();
}
void Doom3ShaderSystem::onFileSystemInitialise() {
realise();
}
// Gets called on VFS initialise
void EClassManager::onFileSystemInitialise()
{
realise();
}
void MaterialShaderSystem::refresh ()
{
unrealise();
realise();
}
void OpenGLRenderSystem::extensionsInitialised()
{
// Determine if lighting is available based on GL extensions
bool glslLightingAvailable = GLEW_VERSION_2_0 ? true : false;
bool arbLightingAvailable = GLEW_VERSION_1_3
&& GLEW_ARB_vertex_program
&& GLEW_ARB_fragment_program;
#if defined(DEBUG_NO_LIGHTING)
glslLightingAvailable = arbLightingAvailable = false;
#endif
rConsole() << "[OpenGLRenderSystem] GLSL shading "
<< (glslLightingAvailable ? "IS" : "IS NOT" ) << " available."
<< std::endl;
rConsole() << "[OpenGLRenderSystem] ARB shading "
<< (arbLightingAvailable ? "IS" : "IS NOT" ) << " available."
<< std::endl;
// Tell the GLProgramFactory which to use
if (glslLightingAvailable)
{
_glProgramFactory->setUsingGLSL(true);
}
else
{
_glProgramFactory->setUsingGLSL(false);
}
// Set internal flags
bool shaderProgramsAvailable = glslLightingAvailable || arbLightingAvailable;
// Set the flag in the openGL module
GlobalOpenGL().setShaderProgramsAvailable(shaderProgramsAvailable);
// Inform the user of missing extensions
if (!shaderProgramsAvailable)
{
rMessage() << "GL shading requires OpenGL features not"
<< " supported by your graphics drivers:\n";
if (!GLEW_VERSION_2_0) {
rMessage() << " GL version 2.0 or better\n";
}
if (!GLEW_ARB_shader_objects) {
rMessage() << " GL_ARB_shader_objects\n";
}
if (!GLEW_ARB_vertex_shader) {
rMessage() << " GL_ARB_vertex_shader\n";
}
if (!GLEW_ARB_fragment_shader) {
rMessage() << " GL_ARB_fragment_shader\n";
}
if (!GLEW_ARB_shading_language_100) {
rMessage() << " GL_ARB_shading_language_100\n";
}
if (!GLEW_ARB_vertex_program) {
rMessage() << " GL_ARB_vertex_program\n";
}
if (!GLEW_ARB_fragment_program) {
rMessage() << " GL_ARB_fragment_program\n";
}
}
// Now that GL extensions are done, we can realise our shaders
// This was previously done explicitly by the OpenGLModule after the
// shared context was created. But we need realised shaders before
// we can fire off the "extensions initialised" signal, map loading
// code might rely on materials being constructed.
realise();
// Notify all our observers
_sigExtensionsInitialised();
}
