void SetTextureUnits(TexIds... args)
{
if (getGLSLVersion() >= 330)
SetTextureUnits_impl<0>(args...);
else
BindTexture<tp...>::template exec<0>(TextureUnits, args...);
}
GLint LoadProgram(AttributeType Tp, Types ... args)
{
GLint ProgramID = glCreateProgram();
loadAndAttach(ProgramID, args...);
if (getGLSLVersion() < 330)
setAttribute(Tp, ProgramID);
glLinkProgram(ProgramID);
GLint Result = GL_FALSE;
int InfoLogLength;
glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
if (Result == GL_FALSE) {
Log::error("GLWrapp", "Error when linking these shaders :");
printFileList(args...);
glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
char *ErrorMessage = new char[InfoLogLength];
glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, ErrorMessage);
Log::error("GLWrapp", ErrorMessage);
delete[] ErrorMessage;
}
GLenum glErr = glGetError();
if (glErr != GL_NO_ERROR)
{
Log::warn("IrrDriver", "GLWrap : OpenGL error %i\n", glErr);
}
return ProgramID;
}
void SetTextureUnits(const std::vector<GLuint> &args)
{
assert(args.size() == sizeof...(tp) && "Too much texture unit provided");
if (getGLSLVersion() >= 330)
{
for (unsigned i = 0; i < args.size(); i++)
{
setTextureSampler(TextureType[i], TextureUnits[i], args[i], SamplersId[i]);
}
}
else
BindTexture<tp...>::exec(TextureUnits, args, 0);
}
void Context::initialize(ContextType contextType) {
// Initialize default state.
reset();
type = contextType;
// Obtain maximum texture size.
glGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint *)&maxTextureSize);
debug(5, "OpenGL maximum texture size: %d", maxTextureSize);
const char *extString = (const char *)glGetString(GL_EXTENSIONS);
bool ARBShaderObjects = false;
bool ARBShadingLanguage100 = false;
bool ARBVertexShader = false;
bool ARBFragmentShader = false;
Common::StringTokenizer tokenizer(extString, " ");
while (!tokenizer.empty()) {
Common::String token = tokenizer.nextToken();
if (token == "GL_ARB_texture_non_power_of_two" || token == "GL_OES_texture_npot") {
NPOTSupported = true;
} else if (token == "GL_ARB_shader_objects") {
ARBShaderObjects = true;
} else if (token == "GL_ARB_shading_language_100") {
ARBShadingLanguage100 = true;
} else if (token == "GL_ARB_vertex_shader") {
ARBVertexShader = true;
} else if (token == "GL_ARB_fragment_shader") {
ARBFragmentShader = true;
} else if (token == "GL_EXT_framebuffer_object") {
framebufferObjectSupported = true;
} else if (token == "GL_EXT_packed_depth_stencil" || token == "GL_OES_packed_depth_stencil") {
packedDepthStencilSupported = true;
} else if (token == "GL_EXT_unpack_subimage") {
unpackSubImageSupported = true;
}
}
int glslVersion = getGLSLVersion();
debug(5, "OpenGL GLSL version: %d", glslVersion);
if (type == kContextGLES2) {
// GLES2 always has (limited) NPOT support.
NPOTSupported = true;
// GLES2 always has shader support.
shadersSupported = true;
// GLES2 always has FBO support.
framebufferObjectSupported = true;
} else {
shadersSupported = ARBShaderObjects && ARBShadingLanguage100 && ARBVertexShader && ARBFragmentShader && glslVersion >= 120;
// Desktop GL always has unpack sub-image support
unpackSubImageSupported = true;
}
// Log context type.
switch (type) {
case kContextGL:
debug(5, "OpenGL: GL context initialized");
break;
case kContextGLES2:
debug(5, "OpenGL: GLES2 context initialized");
break;
}
// Log features supported by GL context.
debug(5, "OpenGL: NPOT texture support: %d", NPOTSupported);
debug(5, "OpenGL: Shader support: %d", shadersSupported);
debug(5, "OpenGL: FBO support: %d", framebufferObjectSupported);
debug(5, "OpenGL: Packed depth stencil support: %d", packedDepthStencilSupported);
debug(5, "OpenGL: Unpack subimage support: %d", unpackSubImageSupported);
}
GLuint GLFuncs::CreateShader(GLenum eShaderType, const std::string &strShaderFile)
{
if (!_useShaders) {
return 0;
}
GLuint shader = glCreateShader(eShaderType);
if (this->_glslVersion == "") {
this->_glslVersion = getGLSLVersion();
if (this->_glslVersion == "") {
this->_glslVersion = "120";
}
}
// Prepend our vertex shader source string with the supported GLSL version so
// the shader will work on ES, Legacy, and OpenGL 3.2 Core Profile contexts
stringstream ss;
ss << "#version " << this->_glslVersion << endl << strShaderFile.c_str();
string shaderTextStr = ss.str();
const GLchar* shaderText = (GLchar*)shaderTextStr.c_str();
Log::Out << shaderText << endl;
glShaderSource(shader, 1, &shaderText, NULL);
glCompileShader(shader);
GLint logLength;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
if (logLength > 0)
{
GLchar *log = (GLchar*)malloc(logLength);
glGetShaderInfoLog(shader, logLength, &logLength, log);
Log::Out << "Shader compile log:" << log << endl;
free(log);
}
GLint status;
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if (status == GL_FALSE)
{
GLint infoLogLength;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
GLchar *strInfoLog = new GLchar[infoLogLength + 1];
glGetShaderInfoLog(shader, infoLogLength, NULL, strInfoLog);
const char *strShaderType = NULL;
switch (eShaderType)
{
case GL_VERTEX_SHADER:
strShaderType = "vertex";
break;
//case GL_GEOMETRY_SHADER: strShaderType = "geometry"; break;
case GL_FRAGMENT_SHADER:
strShaderType = "fragment";
break;
}
Log::Out << "Compile failure in " << strShaderType << " shader:" << endl << strInfoLog << endl;
delete[] strInfoLog;
}
return shader;
}
SDL_Window *GLFuncs::Initialize(int screenWidth, int screenHeight, GLboolean fullscreen, const char* name)
{
Uint32 flags;
if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
Log::Out << "Unable to initialize SDL: " << SDL_GetError() << endl;
return NULL;
}
atexit(SDL_Quit);
flags = SDL_WINDOW_OPENGL;
_screenWidth = screenWidth;
_screenHeight = screenHeight;
_windowWidth = _screenWidth;
_windowHeight = _screenHeight;
if (fullscreen)
{
flags |= SDL_WINDOW_FULLSCREEN;
SDL_DisplayMode currentDisplay;
if(SDL_GetCurrentDisplayMode(0, ¤tDisplay)) {
Log::Out << "Couldn't get current display mode: " << SDL_GetError() << endl;
} else {
Log::Out << "Current display mode: " << currentDisplay.w << "x" << currentDisplay.h << endl;
_windowWidth = currentDisplay.w;
_windowHeight = currentDisplay.h;
}
}
Log::Out << "Window size: " << _windowWidth << "x" << _windowHeight << endl;
int realW, realH;
GetRealSize(&realW, &realH);
Log::Out << "Real size: " << realW << "x" << realH << endl;
this->StaticProjection = glm::ortho(0.0f, (float)_windowWidth, (float)_windowHeight, 0.0f, -1.0f, 1.0f);
setGLAttributes();
_window = SDL_CreateWindow(name,
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
_windowWidth, _windowHeight,
flags);
if (!_window) {
Log::Out << "Unable to create window." << endl;
checkSDLError(__LINE__);
}
SDL_Surface *icon = Pack::GetInstance()->GetImg("data/UWOLIcon.png");
SDL_SetWindowIcon(_window, icon);
_mainContext = SDL_GL_CreateContext(_window);
SDL_GL_MakeCurrent(_window, _mainContext);
#ifndef __APPLE__
glewExperimental = GL_TRUE;
glewInit();
#endif
char* obtainedVersion = (char*)glGetString(GL_VERSION);
string glVersion = getVersionFromStr(obtainedVersion);
Log::Out << "OpenGL: " << obtainedVersion << endl;
int version;
stringstream ss(glVersion);
ss >> version;
#ifdef __APPLE__
this->_useShaders = true;
#else
this->_useShaders = (glCreateProgram != NULL); //version >= 20;
#endif
if (_useShaders) {
this->_vtxAttribIdx = 0;
this->_uvAttribIdx = 1;
this->_colAttribIdx = 2;
this->_glslVersion = getGLSLVersion();
Log::Out << "GLSL: " << (this->_glslVersion == "" ? "Not available!" : this->_glslVersion) << endl;
}
else {
Log::Out << "Shaders are not available" << endl;
}
this->_useVBO = (glGenVertexArrays!=NULL); //version >= 20;
if (this->_useVBO) {
this->_useFramebuffer = this->initFramebuffer();
}
glViewport(0, 0, _screenWidth, _screenHeight);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
// glShadeModel(GL_SMOOTH);
glDisable(GL_CULL_FACE);
//#if !ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
// //glEnable(GL_ALPHA_TEST);
// //glAlphaFunc(GL_GREATER, 0.01f);
// //glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
//#endif
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPointSize(2.0f);
if (this->_useVBO) {
glGenVertexArrays(1, &_vaoVertex);
glBindVertexArray(_vaoVertex);
glGenBuffers(1, &_vboVertex);
glGenBuffers(1, &_vboUV);
glGenBuffers(1, &_vboColor);
glGenBuffers(1, &_vboLineVertex);
}
this->ResetMVP();
GLint texture_units;
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &texture_units);
_activeTextures.resize(texture_units, 0);
return _window;
}
