bool GRAPHICS_GL2::ReloadShaders(
const std::string & shaderpath,
std::ostream & info_output,
std::ostream & error_output)
{
EnableShaders(shaderpath, info_output, error_output);
return GetUsingShaders();
}
void OpenGLEngine::Draw (std::shared_ptr<VertexBuffer> vertexBuffer, std::shared_ptr<IndexBuffer> indexBuffer, std::shared_ptr<VisualEffect> visualEffect)
{
std::shared_ptr<Program> program = visualEffect->GetProgram ();
std::string programName = program->GetProgramName ();
OGLProgram* oglProgram = dynamic_cast<OGLProgram*> (program.get());
if (oglProgram)
{
GLuint programHandle = oglProgram->GetProgramHandle ();
glUseProgram (programHandle);
if (EnableShaders (visualEffect, programHandle))
{
std::shared_ptr<OGLVertexBuffer> oglVertexBuffer = nullptr;
std::shared_ptr<OGLIndexBuffer> oglIndexBuffer = nullptr;
OGLVertexArrayObject* vao = nullptr;
m_MapCO.Get (std::make_pair (vertexBuffer.get(), indexBuffer.get ()), vao);
if (vao)
{
vao->Enable ();
}
else
{
if (vertexBuffer)
{
oglVertexBuffer = std::static_pointer_cast<OGLVertexBuffer> (Bind (vertexBuffer));
}
if (indexBuffer)
{
oglIndexBuffer = std::static_pointer_cast<OGLIndexBuffer> (Bind(indexBuffer));
}
vao = static_cast<OGLVertexArrayObject*> (Bind (oglVertexBuffer, oglIndexBuffer));
}
DrawPrimitive (vertexBuffer.get (), indexBuffer.get ());
vao->Disable ();
DisableShaders (visualEffect, programHandle);
}
else
{
fprintf (stderr, "The draw method in OpenGLEngine failed, because the OGL Program was not correct.\n");
}
}
}
bool GraphicsGL2::ReloadShaders(std::ostream & info_output, std::ostream & error_output)
{
EnableShaders(info_output, error_output);
return GetUsingShaders();
}
bool GraphicsGL2::Init(
const std::string & newshaderpath,
unsigned resx, unsigned resy,
unsigned bpp, unsigned depthbpp,
bool fullscreen, unsigned antialiasing,
bool enableshadows, int new_shadow_distance,
int new_shadow_quality, int reflection_type,
const std::string & static_reflectionmap_file,
const std::string & static_ambientmap_file,
int anisotropy, int texturesize,
int lighting_quality, bool newbloom,
bool newnormalmaps, bool dynamicsky,
const std::string & renderconfig,
std::ostream & info_output,
std::ostream & error_output)
{
shadows = enableshadows;
shadow_distance = new_shadow_distance;
shadow_quality = new_shadow_quality;
lighting = lighting_quality;
bloom = newbloom;
normalmaps = newnormalmaps;
renderconfigfile = renderconfig;
shaderpath = newshaderpath;
sky_dynamic = dynamicsky;
if (reflection_type == 1)
reflection_status = REFLECTION_STATIC;
else if (reflection_type == 2)
reflection_status = REFLECTION_DYNAMIC;
ChangeDisplay(resx, resy, error_output);
fsaa = 1;
if (antialiasing > 1)
fsaa = antialiasing;
if (GLEW_EXT_texture_filter_anisotropic)
glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropy);
info_output << "Maximum anisotropy: " << max_anisotropy << std::endl;
if (renderconfigfile == "noshaders.conf")
{
DisableShaders(error_output);
}
else if (!GLEW_ARB_multitexture)
{
info_output << "Your video card doesn't support multitexturing. Disabling shaders." << std::endl;
DisableShaders(error_output);
}
else if (!GLEW_ARB_texture_cube_map)
{
info_output << "Your video card doesn't support cube maps. Disabling shaders." << std::endl;
DisableShaders(error_output);
}
else if (!GLEW_ARB_texture_non_power_of_two)
{
info_output << "Your video card doesn't support non-power-of-two textures. Disabling shaders." << std::endl;
DisableShaders(error_output);
}
else
{
GLint maxattach;
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &maxattach);
info_output << "Maximum color attachments: " << maxattach << std::endl;
const GLint mrtreq = 1;
GLint mrt = 0;
glGetIntegerv(GL_MAX_DRAW_BUFFERS, &mrt);
info_output << "Maximum draw buffers (" << mrtreq << " required): " << mrt << std::endl;
#ifndef FBOEXT
bool use_fbos = GLEW_ARB_framebuffer_object && mrt >= mrtreq && maxattach >= mrtreq;
#else
bool use_fbos = GLEW_EXT_framebuffer_object && mrt >= mrtreq && maxattach >= mrtreq;
#endif
if (renderconfigfile != "nofbos.conf" && !use_fbos)
{
info_output << "Your video card doesn't support framebuffer objects." << std::endl;
info_output << "Fall back to nofbos.conf." << std::endl;
renderconfigfile = "nofbos.conf";
}
if (GLEW_VERSION_2_0 && GLEW_ARB_shading_language_100 && GLEW_ARB_fragment_shader)
{
if ((reflection_status == REFLECTION_STATIC || reflection_status == REFLECTION_DYNAMIC) && !static_reflectionmap_file.empty())
{
TextureInfo t;
t.cube = true;
t.verticalcross = true;
t.mipmap = true;
t.anisotropy = anisotropy;
t.maxsize = TextureInfo::Size(texturesize);
static_reflection.Load(static_reflectionmap_file, t, error_output);
}
if (!static_ambientmap_file.empty())
{
TextureInfo t;
t.cube = true;
t.verticalcross = true;
t.mipmap = false;
t.anisotropy = anisotropy;
t.maxsize = TextureInfo::Size(texturesize);
static_ambient.Load(static_ambientmap_file, t, error_output);
}
EnableShaders(info_output, error_output);
}
else
{
info_output << "Your video card doesn't support shaders. Fall back to noshaders.conf." << std::endl;
DisableShaders(error_output);
}
}
info_output << "Renderer: " << shaderpath << "/" << renderconfigfile << std::endl;
initialized = true;
return true;
}
bool GraphicsGL2::Init(
const std::string & newshaderpath,
unsigned resx, unsigned resy,
unsigned bpp, unsigned depthbpp,
bool fullscreen, unsigned antialiasing,
bool enableshadows, int new_shadow_distance,
int new_shadow_quality, int reflection_type,
const std::string & static_reflectionmap_file,
const std::string & static_ambientmap_file,
int anisotropy, int texturesize,
int lighting_quality, bool newbloom,
bool newnormalmaps, bool dynamicsky,
const std::string & renderconfig,
std::ostream & info_output,
std::ostream & error_output)
{
assert(!renderconfig.empty() && "Render configuration name string empty.");
if (!GLEW_VERSION_2_0)
{
error_output << "Graphics card or driver does not support required GL_VERSION_2_0." << std::endl;
return false;
}
shadows = enableshadows;
shadow_distance = new_shadow_distance;
shadow_quality = new_shadow_quality;
lighting = lighting_quality;
bloom = newbloom;
normalmaps = newnormalmaps;
renderconfigfile = renderconfig;
shaderpath = newshaderpath;
sky_dynamic = dynamicsky;
if (reflection_type == 1)
reflection_status = REFLECTION_STATIC;
else if (reflection_type == 2)
reflection_status = REFLECTION_DYNAMIC;
fsaa = (antialiasing > 1) ? antialiasing : 1;
ChangeDisplay(resx, resy, error_output);
if (GLEW_EXT_texture_filter_anisotropic)
glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropy);
info_output << "Maximum anisotropy: " << max_anisotropy << std::endl;
GLint maxattach;
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &maxattach);
info_output << "Maximum color attachments: " << maxattach << std::endl;
const GLint mrtreq = 1;
GLint mrt = 0;
glGetIntegerv(GL_MAX_DRAW_BUFFERS, &mrt);
info_output << "Maximum draw buffers (" << mrtreq << " required): " << mrt << std::endl;
#ifndef FBOEXT
bool use_fbos = GLEW_ARB_framebuffer_object && mrt >= mrtreq && maxattach >= mrtreq;
#else
bool use_fbos = GLEW_EXT_framebuffer_object && mrt >= mrtreq && maxattach >= mrtreq;
#endif
if (renderconfigfile != "basic.conf" && !use_fbos)
{
info_output << "Graphics card doesn't support framebuffer objects." << std::endl;
shadows = false;
sky_dynamic = false;
renderconfigfile = "basic.conf";
info_output << "Fall back to: " << renderconfigfile << std::endl;
}
if (!static_reflectionmap_file.empty() && reflection_status != REFLECTION_DISABLED)
{
TextureInfo t;
t.cube = true;
t.verticalcross = true;
t.mipmap = true;
t.anisotropy = anisotropy;
t.maxsize = TextureInfo::Size(texturesize);
static_reflection.Load(static_reflectionmap_file, t, error_output);
}
if (!static_ambientmap_file.empty())
{
TextureInfo t;
t.cube = true;
t.verticalcross = true;
t.mipmap = false;
t.anisotropy = anisotropy;
t.maxsize = TextureInfo::Size(texturesize);
static_ambient.Load(static_ambientmap_file, t, error_output);
}
if (!EnableShaders(info_output, error_output))
{
// try to fall back to basic.conf
if (renderconfigfile != "basic.conf")
{
shadows = false;
sky_dynamic = false;
renderconfigfile = "basic.conf";
info_output << "Fall back to: " << renderconfigfile << std::endl;
if (!EnableShaders(info_output, error_output))
return false;
}
}
if (sky_dynamic)
{
sky.reset(new Sky(*this, error_output));
texture_inputs["sky"] = sky.get();
}
// gl state setup
glEnable(GL_LINE_SMOOTH);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glClearColor(0, 0, 0, 0);
glClearDepth(1);
glPolygonOffset(-1, -1);
info_output << "Renderer: " << shaderpath << "/" << renderconfigfile << std::endl;
initialized = true;
return true;
}
void OpenGLEngine::Draw (std::shared_ptr<VertexBuffer> vertexBuffer, std::shared_ptr<VertexBuffer> instancedBuffer, std::shared_ptr<IndexBuffer> indexBuffer, std::shared_ptr<VisualEffect> visualEffect)
{
std::shared_ptr<Program> program = visualEffect->GetProgram ();
std::string programName = program->GetProgramName ();
OGLProgram* oglProgram = dynamic_cast<OGLProgram*> (program.get());
if (oglProgram)
{
GLuint programHandle = oglProgram->GetProgramHandle ();
glUseProgram (programHandle);
if (EnableShaders (visualEffect, programHandle))
{
std::shared_ptr<OGLVertexBuffer> oglVertexBuffer = nullptr;
std::shared_ptr<OGLVertexBuffer> oglInstancedBuffer = nullptr;
std::shared_ptr<OGLIndexBuffer> oglIndexBuffer = nullptr;
OGLVertexArrayObject* vao = nullptr;
m_MapCO.Get (std::make_pair (vertexBuffer.get(), indexBuffer.get ()), vao);
if (vao)
{
vao->Enable ();
}
else
{
if (vertexBuffer)
{
oglVertexBuffer = std::static_pointer_cast<OGLVertexBuffer> (Bind (vertexBuffer));
}
if (indexBuffer)
{
oglIndexBuffer = std::static_pointer_cast<OGLIndexBuffer> (Bind(indexBuffer));
}
vao = static_cast<OGLVertexArrayObject*> (Bind (oglVertexBuffer, oglIndexBuffer));
oglInstancedBuffer = std::static_pointer_cast<OGLVertexBuffer> (Bind (instancedBuffer));
oglInstancedBuffer->Enable ();
VertexAttributes vertexAttrib = vertexBuffer->GetVertexAttrib ();
VertexAttributes instancedAttrib = instancedBuffer->GetVertexAttrib ();
int vertexBufferNumAttrib = vertexAttrib.GetNumAttrib ();
int instancedBufferNumAttrib = instancedAttrib.GetNumAttrib ();
for (int i = vertexBufferNumAttrib; i < vertexBufferNumAttrib + instancedBufferNumAttrib; i++)
{
ContainerType type = instancedAttrib.GetContainerType (i - vertexBufferNumAttrib);
int offset = instancedAttrib.GetOffset(i - vertexBufferNumAttrib);
int numElements = DataAttributes::GetNumElement (type);
GLenum channelType = oglInstancedBuffer->m_ChannelType[DataAttributes::GetElementType (type)];
size_t vertSize = instancedAttrib.GetVertexSize ();
glEnableVertexAttribArray (i);
glVertexAttribPointer (i, numElements, channelType, GL_FALSE, vertSize, (void*)offset);
glVertexAttribDivisor (i, 1);
}
}
DrawPrimitive (vertexBuffer.get (), instancedBuffer.get (), indexBuffer.get ());
vao->Disable ();
DisableShaders (visualEffect, programHandle);
}
else
{
fprintf (stderr, "The draw method in OpenGLEngine failed, because the OGL Program was not correct.\n");
}
}
}
bool GRAPHICS_GL2::Init(
const std::string & shaderpath,
unsigned int resx, unsigned int resy, unsigned int bpp,
unsigned int depthbpp, bool fullscreen, bool shaders,
unsigned int antialiasing, bool enableshadows, int new_shadow_distance,
int new_shadow_quality, int reflection_type,
const std::string & static_reflectionmap_file,
const std::string & static_ambientmap_file,
int anisotropy, int texturesize,
int lighting_quality, bool newbloom, bool newnormalmaps,
const std::string & renderconfig,
std::ostream & info_output, std::ostream & error_output)
{
shadows = enableshadows;
shadow_distance = new_shadow_distance;
shadow_quality = new_shadow_quality;
lighting = lighting_quality;
bloom = newbloom;
normalmaps = newnormalmaps;
renderconfigfile = renderconfig;
if (reflection_type == 1)
reflection_status = REFLECTION_STATIC;
else if (reflection_type == 2)
reflection_status = REFLECTION_DYNAMIC;
ChangeDisplay(resx, resy, error_output);
fsaa = 1;
if (antialiasing > 1)
fsaa = antialiasing;
if (!GLEW_ARB_multitexture)
{
info_output << "Your video card doesn't support multitexturing. Disabling shaders." << std::endl;
DisableShaders(shaderpath, error_output);
}
else if (!GLEW_ARB_texture_cube_map)
{
info_output << "Your video card doesn't support cube maps. Disabling shaders." << std::endl;
DisableShaders(shaderpath, error_output);
}
else if (!GLEW_ARB_framebuffer_object)
{
info_output << "Your video card doesn't support framebuffer objects. Disabling shaders." << std::endl;
DisableShaders(shaderpath, error_output);
}
else if (!GLEW_ARB_draw_buffers)
{
info_output << "Your video card doesn't support multiple draw buffers. Disabling shaders." << std::endl;
DisableShaders(shaderpath, error_output);
}
else if (!GLEW_ARB_texture_non_power_of_two)
{
info_output << "Your video card doesn't support non-power-of-two textures. Disabling shaders." << std::endl;
DisableShaders(shaderpath, error_output);
}
else if (!GLEW_ARB_texture_float)
{
info_output << "Your video card doesn't support floating point textures. Disabling shaders." << std::endl;
DisableShaders(shaderpath, error_output);
}
else if (!GLEW_ARB_half_float_pixel)
{
info_output << "Your video card doesn't support 16-bit floats. Disabling shaders." << std::endl;
DisableShaders(shaderpath, error_output);
}
else if (!GLEW_ARB_shader_texture_lod && !GLEW_VERSION_2_1) // texture2DLod in logluminance shader
{
info_output << "Your video card doesn't support texture2DLod. Disabling shaders." << std::endl;
DisableShaders(shaderpath, error_output);
}
else
{
GLint maxattach;
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &maxattach);
info_output << "Maximum color attachments: " << maxattach << std::endl;
const GLint reqmrt = 1;
GLint mrt;
glGetIntegerv(GL_MAX_DRAW_BUFFERS, &mrt);
info_output << "Maximum draw buffers (" << reqmrt << " required): " << mrt << std::endl;
if (GLEW_ARB_shading_language_100 && GLEW_VERSION_2_0 && shaders && GLEW_ARB_fragment_shader && mrt >= reqmrt && maxattach >= reqmrt)
{
EnableShaders(shaderpath, info_output, error_output);
}
else
{
info_output << "Disabling shaders" << std::endl;
DisableShaders(shaderpath, error_output);
}
}
//load static reflection map for dynamic reflections too, since we may need it
if ((reflection_status == REFLECTION_STATIC || reflection_status == REFLECTION_DYNAMIC) && !static_reflectionmap_file.empty())
{
TEXTUREINFO t;
t.cube = true;
t.verticalcross = true;
t.mipmap = true;
t.anisotropy = anisotropy;
t.maxsize = TEXTUREINFO::Size(texturesize);
static_reflection.Load(static_reflectionmap_file, t, error_output);
}
if (!static_ambientmap_file.empty())
{
TEXTUREINFO t;
t.cube = true;
t.verticalcross = true;
t.mipmap = false;
t.anisotropy = anisotropy;
t.maxsize = TEXTUREINFO::Size(texturesize);
static_ambient.Load(static_ambientmap_file, t, error_output);
}
if (GLEW_EXT_texture_filter_anisotropic)
glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropy);
info_output << "Maximum anisotropy: " << max_anisotropy << std::endl;
GLUTIL::CheckForOpenGLErrors("Shader loading", error_output);
initialized = true;
return true;
}
bool GraphicsGL2::Init(
const std::string & newshaderpath,
unsigned resx, unsigned resy, unsigned depthbpp,
bool fullscreen, unsigned antialiasing,
bool enableshadows, int new_shadow_distance,
int new_shadow_quality, int reflection_type,
const std::string & static_reflectionmap_file,
const std::string & static_ambientmap_file,
int anisotropy, int texturesize,
int lighting_quality, bool newbloom,
bool newnormalmaps, bool dynamicsky,
const std::string & renderconfig,
std::ostream & info_output,
std::ostream & error_output)
{
assert(!renderconfig.empty() && "Render configuration name string empty.");
const GLubyte * version = glGetString(GL_VERSION);
if (version[0] < '2')
{
error_output << "Graphics card or driver does not support required GL Version: 2.0" << std::endl;
return false;
}
if (version[0] > '2')
{
int major_version = 0;
int minor_version = 0;
glGetIntegerv(GL_MAJOR_VERSION, &major_version);
glGetIntegerv(GL_MINOR_VERSION, &minor_version);
glsl_330 = (major_version > 3 || (major_version == 3 && minor_version >= 3));
}
#ifdef _WIN32
// workaround for broken vao implementation Intel/Windows
{
const std::string vendor = (const char*)glGetString(GL_VENDOR);
if (vendor == "Intel")
vertex_buffer.BindElementBufferExplicitly();
}
#endif
shadows = enableshadows;
shadow_distance = new_shadow_distance;
shadow_quality = new_shadow_quality;
lighting = lighting_quality;
bloom = newbloom;
normalmaps = newnormalmaps;
renderconfigfile = renderconfig;
shaderpath = newshaderpath;
sky_dynamic = dynamicsky;
if (reflection_type == 1)
reflection_status = REFLECTION_STATIC;
else if (reflection_type == 2)
reflection_status = REFLECTION_DYNAMIC;
fsaa = (antialiasing > 1) ? antialiasing : 1;
ChangeDisplay(resx, resy, error_output);
if (GLC_EXT_texture_filter_anisotropic)
glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropy);
info_output << "Maximum anisotropy: " << max_anisotropy << std::endl;
GLint maxattach;
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &maxattach);
info_output << "Maximum color attachments: " << maxattach << std::endl;
const GLint mrtreq = 1;
GLint mrt = 0;
glGetIntegerv(GL_MAX_DRAW_BUFFERS, &mrt);
info_output << "Maximum draw buffers (" << mrtreq << " required): " << mrt << std::endl;
bool use_fbos = GLC_ARB_framebuffer_object && mrt >= mrtreq && maxattach >= mrtreq;
if (renderconfigfile != "basic.conf" && !use_fbos)
{
info_output << "Graphics card doesn't support framebuffer objects." << std::endl;
shadows = false;
sky_dynamic = false;
renderconfigfile = "basic.conf";
info_output << "Fall back to: " << renderconfigfile << std::endl;
}
if (!static_reflectionmap_file.empty() && reflection_status != REFLECTION_DISABLED)
{
TextureInfo t;
t.cube = true;
t.verticalcross = true;
t.mipmap = true;
t.anisotropy = anisotropy;
t.maxsize = TextureInfo::Size(texturesize);
static_reflection.Load(static_reflectionmap_file, t, error_output);
}
if (!static_ambientmap_file.empty())
{
TextureInfo t;
t.cube = true;
t.verticalcross = true;
t.mipmap = false;
t.anisotropy = anisotropy;
t.maxsize = TextureInfo::Size(texturesize);
static_ambient.Load(static_ambientmap_file, t, error_output);
}
if (!EnableShaders(info_output, error_output))
{
// try to fall back to basic.conf
if (renderconfigfile != "basic.conf")
{
shadows = false;
sky_dynamic = false;
renderconfigfile = "basic.conf";
info_output << "Fall back to: " << renderconfigfile << std::endl;
if (!EnableShaders(info_output, error_output))
return false;
}
}
if (sky_dynamic)
{
sky.reset(new Sky(*this, error_output));
texture_inputs["sky"] = sky.get();
}
// gl state setup
glPolygonOffset(-1, -1);
info_output << "Renderer: " << shaderpath << "/" << renderconfigfile << std::endl;
initialized = true;
return true;
}
