static void GlobalGL_sharedContextCreated (void)
{
// report OpenGL information
globalOutputStream() << "GL_VENDOR: " << reinterpret_cast<const char*> (glGetString(GL_VENDOR)) << "\n";
globalOutputStream() << "GL_RENDERER: " << reinterpret_cast<const char*> (glGetString(GL_RENDERER)) << "\n";
globalOutputStream() << "GL_VERSION: " << reinterpret_cast<const char*> (glGetString(GL_VERSION)) << "\n";
globalOutputStream() << "GL_EXTENSIONS: " << reinterpret_cast<const char*> (glGetString(GL_EXTENSIONS)) << "\n";
QGL_sharedContextCreated(GlobalOpenGL());
GlobalShaderCache().realise();
GlobalTexturesCache().realise();
/* use default font here (Sans 10 is gtk default) */
GtkSettings *settings = gtk_settings_get_default();
gchar* fontname;
g_object_get(settings, "gtk-font-name", &fontname, (char*) 0);
g_font = glfont_create(fontname);
// Fallbacks
if (g_font.getPixelHeight() == -1)
g_font = glfont_create("Sans 10");
if (g_font.getPixelHeight() == -1)
g_font = glfont_create("fixed 10");
if (g_font.getPixelHeight() == -1)
g_font = glfont_create("courier new 10");
GlobalOpenGL().m_font = g_font.getDisplayList();
GlobalOpenGL().m_fontHeight = g_font.getPixelHeight();
}
void OpenGLRenderSystem::unrealise()
{
if (!_realised) {
return;
}
_realised = false;
// Unrealise the OpenGLShader objects
for (ShaderMap::iterator i = _shaders.begin(); i != _shaders.end(); ++i)
{
OpenGLShaderPtr sp = i->second;
assert(sp);
sp->unrealise();
}
if (GlobalOpenGL().wxContextValid()
&& GlobalOpenGL().shaderProgramsAvailable()
&& getCurrentShaderProgram() != SHADER_PROGRAM_NONE)
{
// Unrealise the GLPrograms
_glProgramFactory->unrealise();
}
}
TexturePtr DDSImage::bindTexture(const std::string& name) const
{
GLuint textureNum;
GlobalOpenGL().assertNoErrors();
// Allocate a new texture number and store it into the Texture structure
glGenTextures(1, &textureNum);
glBindTexture(GL_TEXTURE_2D, textureNum);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE);
for (std::size_t i = 0; i < _mipMapInfo.size(); ++i)
{
const MipMapInfo& mipMap = _mipMapInfo[i];
glCompressedTexImage2D(
GL_TEXTURE_2D,
static_cast<GLint>(i),
_format,
static_cast<GLsizei>(mipMap.width),
static_cast<GLsizei>(mipMap.height),
0,
static_cast<GLsizei>(mipMap.size),
_pixelData + mipMap.offset
);
// Handle unsupported format error
if (glGetError() == GL_INVALID_ENUM)
{
rConsoleError() << "[DDSImage] Unable to bind texture '"
<< name << "'; unsupported texture format"
<< std::endl;
return TexturePtr();
}
GlobalOpenGL().assertNoErrors();
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, static_cast<GLint>(_mipMapInfo.size() - 1));
// Un-bind the texture
glBindTexture(GL_TEXTURE_2D, 0);
// Create and return texture object
BasicTexture2DPtr texObj(new BasicTexture2D(textureNum, name));
texObj->setWidth(getWidth(0));
texObj->setHeight(getHeight(0));
GlobalOpenGL().assertNoErrors();
return texObj;
}
void GLSLDepthFillProgram::enable()
{
GlobalOpenGL().assertNoErrors();
assert(glIsProgram(_programObj));
glUseProgram(_programObj);
GlobalOpenGL().assertNoErrors();
}
void OpenGLShaderPass::enableTexture2D()
{
GlobalOpenGL().assertNoErrors();
setTexture0();
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
GlobalOpenGL().assertNoErrors();
}
void ARBDepthFillProgram::enable()
{
GlobalOpenGL().assertNoErrors();
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, m_vertex_program);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, m_fragment_program);
GlobalOpenGL().assertNoErrors();
}
/**
* 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 ARBDepthFillProgram::disable()
{
glDisable(GL_VERTEX_PROGRAM_ARB);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
GlobalOpenGL().assertNoErrors();
}
void render (RenderStateFlags state) const
{
if (m_particle != 0) {
glRasterPos3fv(m_origin);
GlobalOpenGL().drawString(m_particle->getName());
}
}
void OpenGLShaderPass::disableRenderBlend()
{
glDisable(GL_BLEND);
setTexture0();
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GlobalOpenGL().assertNoErrors();
}
void RenderPreview::drawTime()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, static_cast<float>(_previewWidth), 0, static_cast<float>(_previewHeight), -100, 100);
glScalef(1, -1, 1);
glTranslatef(0, -static_cast<float>(_previewHeight), 0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if (GLEW_VERSION_1_3)
{
glClientActiveTexture(GL_TEXTURE0);
glActiveTexture(GL_TEXTURE0);
}
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_DEPTH_TEST);
glColor3f( 1.f, 1.f, 1.f );
glLineWidth(1);
glRasterPos3f(1.0f, static_cast<float>(_previewHeight) - 1.0f, 0.0f);
GlobalOpenGL().drawString((boost::format("%.3f sec.") % (_renderSystem->getTime() * 0.001f)).str());
}
void ARBDepthFillProgram::destroy()
{
glDeleteProgramsARB(1, &m_vertex_program);
glDeleteProgramsARB(1, &m_fragment_program);
GlobalOpenGL().assertNoErrors();
}
// Enable cubemap texturing and texcoord array
void OpenGLShaderPass::enableTextureCubeMap()
{
setTexture0();
glEnable(GL_TEXTURE_CUBE_MAP);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
GlobalOpenGL().assertNoErrors();
}
void OpenGLShaderPass::disableTexture2D()
{
setTexture0();
glDisable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
GlobalOpenGL().assertNoErrors();
}
GLuint GLProgramFactory::createGLSLProgram(const std::string& vFile,
const std::string& fFile)
{
// Create the parent program object
GLuint program = glCreateProgram();
// Create the shader objects
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
// Load the source files as NULL-terminated strings and pass the text to
// OpenGL
CharBufPtr vertexSrc = getFileAsBuffer(vFile, true);
CharBufPtr fragSrc = getFileAsBuffer(fFile, true);
const char* csVertex = &vertexSrc->front();
const char* csFragment = &fragSrc->front();
glShaderSource(vertexShader, 1, &csVertex, NULL);
glShaderSource(fragmentShader, 1, &csFragment, NULL);
GlobalOpenGL().assertNoErrors();
// Compile the shaders
glCompileShader(vertexShader);
assertShaderCompiled(vertexShader);
glCompileShader(fragmentShader);
assertShaderCompiled(fragmentShader);
GlobalOpenGL().assertNoErrors();
// Attach and link the program object itself
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
GlobalOpenGL().assertNoErrors();
glLinkProgram(program);
// Check the link status and throw an exception if it failed
assertProgramLinked(program);
// Return the linked program
return program;
}
gint glwidget_context_destroyed( GtkWidget* widget, gpointer data ){
if ( --g_context_count == 0 ) {
GlobalOpenGL().contextValid = false;
GLWidget_sharedContextDestroyed();
gtk_widget_unref( g_shared );
g_shared = 0;
}
return FALSE;
}
void GLSLDepthFillProgram::create()
{
// Create the program object
rConsole() << "[renderer] Creating GLSL depthfill program" << std::endl;
_programObj = GLProgramFactory::createGLSLProgram(
DEPTHFILL_VP_FILENAME, DEPTHFILL_FP_FILENAME
);
GlobalOpenGL().assertNoErrors();
}
void RenderablePatchSolid::render(const RenderInfo& info) const
{
#ifdef PATCHES_USE_VBO
glBindBuffer(GL_ARRAY_BUFFER, _vboData);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vboIdx);
glNormalPointer(GL_DOUBLE, sizeof(ArbitraryMeshVertex), BUFFER_OFFSET(16));
glClientActiveTexture(GL_TEXTURE0);
glTexCoordPointer(2, GL_DOUBLE, sizeof(ArbitraryMeshVertex), BUFFER_OFFSET(0));
glVertexPointer(3, GL_DOUBLE, sizeof(ArbitraryMeshVertex), BUFFER_OFFSET(40));
const RenderIndex* strip_indices = 0;
for (std::size_t i = 0; i < m_tess.m_numStrips; i++, strip_indices += m_tess.m_lenStrips)
{
glDrawElements(GL_QUAD_STRIP, GLsizei(m_tess.m_lenStrips), RenderIndexTypeID, strip_indices);
}
GlobalOpenGL().assertNoErrors();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
#else
if (m_tess.vertices.empty() || m_tess.indices.empty()) return;
if (info.checkFlag(RENDER_BUMP))
{
glVertexAttribPointerARB(11, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().normal);
glVertexAttribPointerARB(8, 2, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().texcoord);
glVertexAttribPointerARB(9, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().tangent);
glVertexAttribPointerARB(10, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().bitangent);
}
else
{
glNormalPointer(GL_DOUBLE, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().normal);
glTexCoordPointer(2, GL_DOUBLE, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().texcoord);
}
glVertexPointer(3, GL_DOUBLE, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().vertex);
const RenderIndex* strip_indices = &m_tess.indices.front();
for(std::size_t i = 0; i<m_tess.m_numStrips; i++, strip_indices += m_tess.m_lenStrips)
{
glDrawElements(GL_QUAD_STRIP, GLsizei(m_tess.m_lenStrips), RenderIndexTypeID, strip_indices);
}
#if defined(_DEBUG)
//RenderNormals();
#endif
#endif
}
void ClipPoint::Draw(const std::string& label, float scale) {
// draw point
glBegin (GL_POINTS);
glVertex3dv(_coords);
glEnd();
float offset = 2.0f / scale;
// draw label
glRasterPos3f (_coords[0] + offset, _coords[1] + offset, _coords[2] + offset);
GlobalOpenGL().drawString(label);
}
gint glwidget_context_created( GtkWidget* widget, gpointer data ){
if ( ++g_context_count == 1 ) {
g_shared = widget;
gtk_widget_ref( g_shared );
glwidget_make_current( g_shared );
GlobalOpenGL().contextValid = true;
GLWidget_sharedContextCreated();
}
return FALSE;
}
gint GLWidget::onUnRealise(GtkWidget* widget, GLWidget* self) {
if (--g_context_count == 0) {
GlobalOpenGL().contextValid = false;
GLWidget_sharedContextDestroyed();
gtk_widget_unref(g_shared);
g_shared = NULL;
}
return FALSE;
}
gint GLWidget::onRealise(GtkWidget* widget, GLWidget* self) {
if (++g_context_count == 1) {
g_shared = widget;
gtk_widget_ref(g_shared);
makeCurrent(g_shared);
GlobalOpenGL().contextValid = true;
GLWidget_sharedContextCreated();
}
return FALSE;
}
void RenderablePatchSolid::update()
{
#ifdef PATCHES_USE_VBO
// Space needed for geometry
std::size_t dataSize = sizeof(ArbitraryMeshVertex)*m_tess.vertices.size();
std::size_t indexSize = sizeof(RenderIndex)*m_tess.indices.size();
// Initialise the vertex buffer
glBindBuffer(GL_ARRAY_BUFFER, _vboData);
// Allocate space for vertices
glBufferData(GL_ARRAY_BUFFER, dataSize, NULL, GL_STATIC_DRAW);
GlobalOpenGL().assertNoErrors();
// Upload the data
glBufferSubData(GL_ARRAY_BUFFER, 0, dataSize, &m_tess.vertices[0]);
GlobalOpenGL().assertNoErrors();
// Initialise the index buffer
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vboIdx);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexSize, NULL, GL_STATIC_DRAW);
GlobalOpenGL().assertNoErrors();
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, indexSize, &m_tess.indices[0]);
GlobalOpenGL().assertNoErrors();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
GlobalOpenGL().assertNoErrors();
#endif
}
void ARBDepthFillProgram::create()
{
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
// Create the vertex program
m_vertex_program = GLProgramFactory::createARBProgram(
DEPTHFILL_VP_FILENAME, GL_VERTEX_PROGRAM_ARB
);
// Create the fragment program
m_fragment_program = GLProgramFactory::createARBProgram(
DEPTHFILL_FP_FILENAME, GL_FRAGMENT_PROGRAM_ARB
);
glDisable(GL_VERTEX_PROGRAM_ARB);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
GlobalOpenGL().assertNoErrors();
}
GLuint GLProgramFactory::createARBProgram(const std::string& filename,
GLenum type)
{
// Get the file contents without NULL terminator
CharBufPtr buffer = getFileAsBuffer(filename, false);
// Bind the program data into OpenGL
GlobalOpenGL().assertNoErrors();
GLuint programID;
glGenProgramsARB(1, &programID);
glBindProgramARB(type, programID);
glProgramStringARB(
type,
GL_PROGRAM_FORMAT_ASCII_ARB,
GLsizei(buffer->size()),
&buffer->front()
);
// Check for GL errors and throw exception if there is a problem
if (GL_INVALID_OPERATION == glGetError())
{
GLint errPos;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
const GLubyte* errString = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
// Construct user-readable error string
std::string error("GL program error: ");
error += filename + "(" + string::to_string(errPos) + "): \n\n";
error += std::string(reinterpret_cast<const char*>(errString));
rConsoleError() << error << std::endl;
}
// Return the new program
return programID;
}
void RenderPreview::onGLMotion(wxMouseEvent& ev)
{
if (ev.LeftIsDown()) // dragging with mouse button
{
static double _lastX = ev.GetX();
static double _lastY = ev.GetY();
// Calculate the mouse delta as a vector in the XY plane, and store the
// current position for the next event.
Vector3 deltaPos(static_cast<float>(ev.GetX() - _lastX),
static_cast<float>(_lastY - ev.GetY()),
0);
_lastX = ev.GetX();
_lastY = ev.GetY();
// Calculate the axis of rotation. This is the mouse vector crossed with the Z axis,
// to give a rotation axis in the XY plane at right-angles to the mouse delta.
static Vector3 _zAxis(0, 0, 1);
Vector3 axisRot = deltaPos.crossProduct(_zAxis);
// Grab the contex for this widget
if (_glWidget->SetCurrent(GlobalOpenGL().getwxGLContext()))
{
// Premultiply the current modelview matrix with the rotation,
// in order to achieve rotations in eye space rather than object
// space. At this stage we are only calculating and storing the
// matrix for the GLDraw callback to use.
glLoadIdentity();
glRotated(-2, axisRot.x(), axisRot.y(), axisRot.z());
glMultMatrixd(_rotation);
// Save the new GL matrix for GL draw
glGetDoublev(GL_MODELVIEW_MATRIX, _rotation);
_glWidget->Refresh(); // trigger the GLDraw method to draw the actual model
}
}
}
void OpenGLRenderSystem::realise()
{
if (_realised) {
return; // already realised
}
_realised = true;
if (GlobalOpenGL().shaderProgramsAvailable()
&& getCurrentShaderProgram() != SHADER_PROGRAM_NONE)
{
// Realise the GLPrograms
_glProgramFactory->realise();
}
// Realise the OpenGLShader objects
for (ShaderMap::iterator i = _shaders.begin(); i != _shaders.end(); ++i)
{
OpenGLShaderPtr sp = i->second;
assert(sp);
sp->realise(i->first);
}
}
// Apply own state to current state object
void OpenGLShaderPass::applyState(OpenGLState& current,
unsigned int globalStateMask,
const Vector3& viewer)
{
if(_state.renderFlags & RENDER_OVERRIDE)
{
globalStateMask |= RENDER_FILL | RENDER_DEPTHWRITE;
}
// Apply the global state mask to our own desired render flags to determine
// the final set of flags that must bet set
const unsigned int requiredState = _state.renderFlags & globalStateMask;
// Construct a mask containing all the flags that will be changing between
// the current state and the required state. This avoids performing
// unnecessary GL calls to set the state to its existing value.
const unsigned int changingBitsMask = requiredState ^ current.renderFlags;
// Set the GLProgram if required
GLProgram* program = (requiredState & RENDER_PROGRAM) != 0
? _state.glProgram
: 0;
if(program != current.glProgram)
{
if(current.glProgram != 0)
{
current.glProgram->disable();
glColor4dv(current.m_colour);
}
current.glProgram = program;
if(current.glProgram != 0)
{
current.glProgram->enable();
}
}
// State changes. Only perform these if changingBitsMask > 0, since if there are
// no changes required we don't want a whole load of unnecessary bit
// operations.
if (changingBitsMask != 0)
{
if(changingBitsMask & requiredState & RENDER_FILL)
{
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
GlobalOpenGL().assertNoErrors();
}
else if(changingBitsMask & ~requiredState & RENDER_FILL)
{
glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
GlobalOpenGL().assertNoErrors();
}
setState(requiredState, changingBitsMask, RENDER_OFFSETLINE, GL_POLYGON_OFFSET_LINE);
if(changingBitsMask & requiredState & RENDER_LIGHTING)
{
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glEnableClientState(GL_NORMAL_ARRAY);
GlobalOpenGL().assertNoErrors();
}
else if(changingBitsMask & ~requiredState & RENDER_LIGHTING)
{
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
glDisableClientState(GL_NORMAL_ARRAY);
GlobalOpenGL().assertNoErrors();
}
// RENDER_TEXTURE_2D
if(changingBitsMask & requiredState & RENDER_TEXTURE_2D)
{
enableTexture2D();
}
else if(changingBitsMask & ~requiredState & RENDER_TEXTURE_2D)
{
disableTexture2D();
}
// RENDER_TEXTURE_CUBEMAP
if(changingBitsMask & requiredState & RENDER_TEXTURE_CUBEMAP)
{
enableTextureCubeMap();
}
else if(changingBitsMask & ~requiredState & RENDER_TEXTURE_CUBEMAP)
{
disableTextureCubeMap();
}
// RENDER_BLEND
if(changingBitsMask & requiredState & RENDER_BLEND)
{
enableRenderBlend();
}
else if(changingBitsMask & ~requiredState & RENDER_BLEND)
{
disableRenderBlend();
}
setState(requiredState, changingBitsMask, RENDER_CULLFACE, GL_CULL_FACE);
if(changingBitsMask & requiredState & RENDER_SMOOTH)
{
glShadeModel(GL_SMOOTH);
GlobalOpenGL().assertNoErrors();
}
else if(changingBitsMask & ~requiredState & RENDER_SMOOTH)
{
glShadeModel(GL_FLAT);
GlobalOpenGL().assertNoErrors();
}
setState(requiredState, changingBitsMask, RENDER_SCALED, GL_NORMALIZE); // not GL_RESCALE_NORMAL
setState(requiredState, changingBitsMask, RENDER_DEPTHTEST, GL_DEPTH_TEST);
if(changingBitsMask & requiredState & RENDER_DEPTHWRITE)
{
glDepthMask(GL_TRUE);
GlobalOpenGL().assertNoErrors();
}
else if(changingBitsMask & ~requiredState & RENDER_DEPTHWRITE)
{
glDepthMask(GL_FALSE);
GlobalOpenGL().assertNoErrors();
}
if(changingBitsMask & requiredState & RENDER_COLOURWRITE)
{
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
GlobalOpenGL().assertNoErrors();
}
else if(changingBitsMask & ~requiredState & RENDER_COLOURWRITE)
{
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
GlobalOpenGL().assertNoErrors();
}
setState(requiredState, changingBitsMask, RENDER_ALPHATEST, GL_ALPHA_TEST);
if(changingBitsMask & requiredState & RENDER_COLOURARRAY)
{
glEnableClientState(GL_COLOR_ARRAY);
GlobalOpenGL().assertNoErrors();
}
else if(changingBitsMask & ~requiredState & RENDER_COLOURARRAY)
{
glDisableClientState(GL_COLOR_ARRAY);
glColor4dv(_state.m_colour);
GlobalOpenGL().assertNoErrors();
}
if(changingBitsMask & ~requiredState & RENDER_COLOURCHANGE)
{
glColor4dv(_state.m_colour);
GlobalOpenGL().assertNoErrors();
}
// Set GL states corresponding to RENDER_ flags
setState(requiredState, changingBitsMask, RENDER_LINESTIPPLE, GL_LINE_STIPPLE);
setState(requiredState, changingBitsMask, RENDER_LINESMOOTH, GL_LINE_SMOOTH);
setState(requiredState, changingBitsMask, RENDER_POLYGONSTIPPLE, GL_POLYGON_STIPPLE);
setState(requiredState, changingBitsMask, RENDER_POLYGONSMOOTH, GL_POLYGON_SMOOTH);
} // end of changingBitsMask-dependent changes
if(requiredState & RENDER_DEPTHTEST && _state.m_depthfunc != current.m_depthfunc)
{
glDepthFunc(_state.m_depthfunc);
GlobalOpenGL().assertNoErrors();
current.m_depthfunc = _state.m_depthfunc;
}
if(requiredState & RENDER_LINESTIPPLE
&& (_state.m_linestipple_factor != current.m_linestipple_factor
|| _state.m_linestipple_pattern != current.m_linestipple_pattern))
{
glLineStipple(_state.m_linestipple_factor, _state.m_linestipple_pattern);
GlobalOpenGL().assertNoErrors();
current.m_linestipple_factor = _state.m_linestipple_factor;
current.m_linestipple_pattern = _state.m_linestipple_pattern;
}
// Set up the alpha test parameters
if (requiredState & RENDER_ALPHATEST
&& ( _state.alphaFunc != current.alphaFunc
|| _state.alphaThreshold != current.alphaThreshold)
)
{
// Set alpha function in GL
glAlphaFunc(_state.alphaFunc, _state.alphaThreshold);
GlobalOpenGL().assertNoErrors();
// Store state values
current.alphaFunc = _state.alphaFunc;
current.alphaThreshold = _state.alphaThreshold;
}
// Apply polygon offset
if (_state.polygonOffset != current.polygonOffset)
{
current.polygonOffset = _state.polygonOffset;
if (current.polygonOffset > 0.0f)
{
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(-1, -1 *_state.polygonOffset);
}
else
{
glDisable(GL_POLYGON_OFFSET_FILL);
}
}
// Apply the GL textures
applyAllTextures(current, requiredState);
// Set the GL colour if it isn't set already
if (_state.m_colour != current.m_colour)
{
glColor4dv(_state.m_colour);
current.m_colour = _state.m_colour;
GlobalOpenGL().assertNoErrors();
}
// Set up the cubemap and texgen parameters
setUpCubeMapAndTexGen(current, requiredState, viewer);
if(requiredState & RENDER_BLEND
&& (_state.m_blend_src != current.m_blend_src || _state.m_blend_dst != current.m_blend_dst))
{
glBlendFunc(_state.m_blend_src, _state.m_blend_dst);
GlobalOpenGL().assertNoErrors();
current.m_blend_src = _state.m_blend_src;
current.m_blend_dst = _state.m_blend_dst;
}
if(!(requiredState & RENDER_FILL)
&& _state.m_linewidth != current.m_linewidth)
{
glLineWidth(_state.m_linewidth);
GlobalOpenGL().assertNoErrors();
current.m_linewidth = _state.m_linewidth;
}
if(!(requiredState & RENDER_FILL)
&& _state.m_pointsize != current.m_pointsize)
{
glPointSize(_state.m_pointsize);
GlobalOpenGL().assertNoErrors();
current.m_pointsize = _state.m_pointsize;
}
current.renderFlags = requiredState;
GlobalOpenGL().assertNoErrors();
}
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();
}
void CamWnd::Cam_Draw() {
glViewport(0, 0, m_Camera.width, m_Camera.height);
// enable depth buffer writes
glDepthMask(GL_TRUE);
Vector3 clearColour(0, 0, 0);
clearColour = ColourSchemes().getColourVector3("camera_background");
glClearColor(clearColour[0], clearColour[1], clearColour[2], 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
render::RenderStatistics::Instance().resetStats();
Cull_ResetStats();
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(m_Camera.projection);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(m_Camera.modelview);
// one directional light source directly behind the viewer
{
GLfloat inverse_cam_dir[4], ambient[4], diffuse[4];//, material[4];
ambient[0] = ambient[1] = ambient[2] = 0.4f;
ambient[3] = 1.0f;
diffuse[0] = diffuse[1] = diffuse[2] = 0.4f;
diffuse[3] = 1.0f;
inverse_cam_dir[0] = m_Camera.vpn[0];
inverse_cam_dir[1] = m_Camera.vpn[1];
inverse_cam_dir[2] = m_Camera.vpn[2];
inverse_cam_dir[3] = 0;
glLightfv(GL_LIGHT0, GL_POSITION, inverse_cam_dir);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glEnable(GL_LIGHT0);
}
unsigned int globalstate = RENDER_DEPTHTEST | RENDER_COLOURWRITE | RENDER_DEPTHWRITE | RENDER_ALPHATEST
| RENDER_BLEND | RENDER_CULLFACE | RENDER_COLOURARRAY | RENDER_COLOURCHANGE;
switch (getCameraSettings()->getMode()) {
case drawWire:
break;
case drawSolid:
globalstate |= (RENDER_FILL | RENDER_LIGHTING | RENDER_SMOOTH | RENDER_SCALED);
break;
case drawTexture:
globalstate |= (RENDER_FILL | RENDER_LIGHTING | RENDER_TEXTURE_2D | RENDER_SMOOTH | RENDER_SCALED);
break;
default:
globalstate = 0;
break;
}
if (!getCameraSettings()->solidSelectionBoxes()) {
globalstate |= RENDER_LINESTIPPLE;
}
{
CamRenderer renderer(globalstate, m_state_select2, m_state_select1, m_view.getViewer());
Scene_Render(renderer, m_view);
renderer.render(m_Camera.modelview, m_Camera.projection);
}
// greebo: Draw the clipper's points (skipping the depth-test)
{
glDisable(GL_DEPTH_TEST);
glColor4f(1, 1, 1, 1);
glPointSize(5);
if (GlobalClipper().clipMode()) {
GlobalClipper().draw(1.0f);
}
glPointSize(1);
}
// prepare for 2d stuff
glColor4f(1, 1, 1, 1);
glDisable(GL_BLEND);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, (float) m_Camera.width, 0, (float) m_Camera.height, -100, 100);
glScalef(1, -1, 1);
glTranslatef(0, -(float) m_Camera.height, 0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if (GlobalOpenGL().GL_1_3()) {
glClientActiveTexture(GL_TEXTURE0);
glActiveTexture(GL_TEXTURE0);
}
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_DEPTH_TEST);
glLineWidth(1);
// draw the crosshair
if (m_bFreeMove) {
glBegin(GL_LINES);
glVertex2f((float) m_Camera.width / 2.f, (float) m_Camera.height / 2.f + 6);
glVertex2f((float) m_Camera.width / 2.f, (float) m_Camera.height / 2.f + 2);
glVertex2f((float) m_Camera.width / 2.f, (float) m_Camera.height / 2.f - 6);
glVertex2f((float) m_Camera.width / 2.f, (float) m_Camera.height / 2.f - 2);
glVertex2f((float) m_Camera.width / 2.f + 6, (float) m_Camera.height / 2.f);
glVertex2f((float) m_Camera.width / 2.f + 2, (float) m_Camera.height / 2.f);
glVertex2f((float) m_Camera.width / 2.f - 6, (float) m_Camera.height / 2.f);
glVertex2f((float) m_Camera.width / 2.f - 2, (float) m_Camera.height / 2.f);
glEnd();
}
glRasterPos3f(1.0f, static_cast<float> (m_Camera.height) - 1.0f, 0.0f);
GlobalOpenGL().drawString(render::RenderStatistics::Instance().getStatString());
glRasterPos3f(1.0f, static_cast<float> (m_Camera.height) - 11.0f, 0.0f);
GlobalOpenGL().drawString(Cull_GetStats());
// bind back to the default texture so that we don't have problems
// elsewhere using/modifying texture maps between contexts
glBindTexture(GL_TEXTURE_2D, 0);
}
