void OpenGLModule::sharedContextCreated()
{
// 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";
GLenum err = glewInit();
if (err != GLEW_OK) {
// glewInit failed
globalErrorStream() << "GLEW error: " <<
reinterpret_cast<const char*>(glewGetErrorString(err));
}
GlobalRenderSystem().extensionsInitialised();
GlobalRenderSystem().realise();
_font = glfont_create("Sans 8");
m_font = _font.getDisplayList();
m_fontHeight = _font.getPixelHeight();
}
void OpenGLModule::sharedContextCreated()
{
// report OpenGL information
rMessage() << "GL_VENDOR: "
<< reinterpret_cast<const char*>(glGetString(GL_VENDOR)) << std::endl;
rMessage() << "GL_RENDERER: "
<< reinterpret_cast<const char*>(glGetString(GL_RENDERER)) << std::endl;
rMessage() << "GL_VERSION: "
<< reinterpret_cast<const char*>(glGetString(GL_VERSION)) << std::endl;
rMessage() << "GL_EXTENSIONS: "
<< reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)) << std::endl;
GLenum err = glewInit();
if (err != GLEW_OK)
{
// glewInit failed
rError() << "GLEW error: " <<
reinterpret_cast<const char*>(glewGetErrorString(err));
}
GlobalRenderSystem().extensionsInitialised();
GlobalRenderSystem().realise();
_font.reset(new wxutil::GLFont(wxutil::GLFont::FONT_SANS, 12));
}
void RadiantSelectionSystem::initialiseModule(const ApplicationContext& ctx)
{
rMessage() << "RadiantSelectionSystem::initialiseModule called.\n";
constructStatic();
SetManipulatorMode(eTranslate);
pivotChanged();
_sigSelectionChanged.connect(
sigc::mem_fun(this, &RadiantSelectionSystem::pivotChangedSelection)
);
GlobalGrid().signal_gridChanged().connect(
sigc::mem_fun(this, &RadiantSelectionSystem::pivotChanged)
);
GlobalRegistry().signalForKey(RKEY_ROTATION_PIVOT).connect(
sigc::mem_fun(this, &RadiantSelectionSystem::keyChanged)
);
// Pass a reference to self to the global event manager
GlobalEventManager().connectSelectionSystem(this);
// Connect the bounds changed caller
GlobalSceneGraph().signal_boundsChanged().connect(
sigc::mem_fun(this, &RadiantSelectionSystem::onSceneBoundsChanged)
);
GlobalRenderSystem().attachRenderable(*this);
}
void MD5ModelNode::constructRemaps() {
// greebo: Acquire the ModelSkin reference from the SkinCache
// Note: This always returns a valid reference
ModelSkin& skin = GlobalModelSkinCache().capture(_skin);
// Iterate over all surfaces and remaps
_surfaceRemaps.resize(_model->size());
MD5ModelNode::SurfaceRemaps::iterator j = _surfaceRemaps.begin();
for (MD5Model::const_iterator i = _model->begin(); i != _model->end(); ++i,++j) {
// Get the replacement shadername
std::string remap = skin.getRemap((*i)->getShader());
if (!remap.empty()) {
// We have a valid remap, store it
j->name = remap;
j->shader = GlobalRenderSystem().capture(remap);
} else {
// No remap, leave the name as it is
j->shader = ShaderPtr();
}
}
// Refresh the scene
GlobalSceneGraph().sceneChanged();
}
void SpacePartitionRenderer::uninstallRenderer()
{
_renderableSP.setRenderSystem(RenderSystemPtr());
_renderableSP.setSpacePartition(scene::ISpacePartitionSystemPtr());
GlobalRenderSystem().detachRenderable(_renderableSP);
}
void LightNode::onInsertIntoScene()
{
// Call the base class first
EntityNode::onInsertIntoScene();
GlobalRenderSystem().attachLight(*this);
}
void SpacePartitionRenderer::installRenderer()
{
_renderableSP.setSpacePartition(GlobalSceneGraph().getSpacePartition());
_renderableSP.setRenderSystem(boost::dynamic_pointer_cast<RenderSystem>(
module::GlobalModuleRegistry().getModule(MODULE_RENDERSYSTEM)));
GlobalRenderSystem().attachRenderable(_renderableSP);
}
MD5ModelNode::MD5ModelNode(const MD5ModelPtr& model) :
_model(new MD5Model(*model)), // create a copy of the incoming model, we need our own instance
_surfaceLightLists(_model->size())
{
_lightList = &GlobalRenderSystem().attachLitObject(*this);
Node::setTransformChangedCallback(Callback((boost::bind(&MD5ModelNode::lightsChanged, this))));
}
void MapPreview::initialisePreview() {
// Grab the GL widget with sentry object
gtkutil::GLWidgetSentry sentry(_glWidget);
// Clear the window
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glClearColor(0.0, 0.0, 0.0, 0);
glClearDepth(100.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Set up the camera
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(PREVIEW_FOV, 1, 0.1, 10000);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Set up the lights
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
GLfloat l0Amb[] = { 0.3f, 0.3f, 0.3f, 1.0f };
GLfloat l0Dif[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat l0Pos[] = { 1.0f, 1.0f, 1.0f, 0.0f };
glLightfv(GL_LIGHT0, GL_AMBIENT, l0Amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, l0Dif);
glLightfv(GL_LIGHT0, GL_POSITION, l0Pos);
glEnable(GL_LIGHT1);
GLfloat l1Dif[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat l1Pos[] = { 0.0, 0.0, 1.0, 0.0 };
glLightfv(GL_LIGHT1, GL_DIFFUSE, l1Dif);
glLightfv(GL_LIGHT1, GL_POSITION, l1Pos);
// Reset the rotation
_rotation = Matrix4::getIdentity();
// Calculate camera distance so model is appropriately zoomed
_camDist = -(20 * 2.0);
_stateSelect1 = GlobalRenderSystem().capture("$CAM_HIGHLIGHT");
_stateSelect2 = GlobalRenderSystem().capture("$CAM_OVERLAY");
}
// Capture the shaders for the current colour
void Doom3EntityClass::captureColour()
{
// Set the entity colour to default, if none was specified
if (_colour == Vector3(-1, -1, -1)) {
_colour = ColourSchemes().getColour("default_entity");
}
// Capture fill and wire versions of the entity colour
std::string fillCol = _colourTransparent ?
(boost::format("[%g %g %g]") % _colour[0] % _colour[1] % _colour[2]).str() :
(boost::format("(%g %g %g)") % _colour[0] % _colour[1] % _colour[2]).str();
std::string wireCol = (boost::format("<%g %g %g>") % _colour[0] % _colour[1] % _colour[2]).str();
_fillShader = GlobalRenderSystem().capture(fillCol);
_wireShader = GlobalRenderSystem().capture(wireCol);
}
void Doom3EntityCreator::initialiseModule(const ApplicationContext& ctx)
{
globalOutputStream() << "Doom3EntityCreator::initialiseModule called." << std::endl;
LightShader::m_defaultShader = GlobalRegistry().get("game/defaults/lightShader");
// Construct Doom3Group stuff
CurveEditInstance::initialiseShaders();
RenderablePivot::StaticShader() = GlobalRenderSystem().capture("$PIVOT");
GlobalRenderSystem().attachRenderable(RenderableTargetInstances::Instance());
GlobalEventManager().addRegistryToggle("ToggleShowAllLightRadii", RKEY_SHOW_ALL_LIGHT_RADII);
GlobalEventManager().addRegistryToggle("ToggleShowAllSpeakerRadii", RKEY_SHOW_ALL_SPEAKER_RADII);
GlobalEventManager().addRegistryToggle("ToggleDragResizeEntitiesSymmetrically", RKEY_DRAG_RESIZE_SYMMETRICALLY);
}
void Doom3EntityCreator::shutdownModule()
{
globalOutputStream() << "Doom3EntityCreator::shutdownModule called." << std::endl;
GlobalRenderSystem().detachRenderable(RenderableTargetInstances::Instance());
// Destroy the settings instance
EntitySettings::destroy();
}
// greebo: Construct a new RenderablePicoModel instance, we re-use the surfaces only
PicoModelNode::PicoModelNode(const RenderablePicoModelPtr& picoModel) :
_picoModel(new RenderablePicoModel(*picoModel)),
_name(picoModel->getFilename()),
_lightList(GlobalRenderSystem().attachLitObject(*this))
{
Node::setTransformChangedCallback(boost::bind(&PicoModelNode::lightsChanged, this));
// Update the skin
skinChanged("");
}
void Doom3MapCompiler::shutdownModule()
{
if (_debugRenderer)
{
GlobalRenderSystem().detachRenderable(*_debugRenderer);
_debugRenderer.reset();
}
_procFile.reset();
}
void RadiantSelectionSystem::shutdownModule()
{
// greebo: Unselect everything so that no references to scene::Nodes
// are kept after shutdown, causing destruction issues.
setSelectedAll(false);
setSelectedAllComponents(false);
GlobalRenderSystem().detachRenderable(*this);
destroyStatic();
}
void LightNode::onRemoveFromScene()
{
// Call the base class first
EntityNode::onRemoveFromScene();
GlobalRenderSystem().detachLight(*this);
// De-select all child components as well
setSelectedComponents(false, SelectionSystem::eVertex);
setSelectedComponents(false, SelectionSystem::eFace);
}
MD5ModelNode::MD5ModelNode(const MD5ModelPtr& model) :
_model(model),
_surfaceLightLists(_model->size()),
_surfaceRemaps(_model->size())
{
_lightList = &GlobalRenderSystem().attach(*this);
Node::setTransformChangedCallback(Callback((boost::bind(&MD5ModelNode::lightsChanged, this))));
constructRemaps();
}
void GlyphSet::realiseShaders()
{
// For each glyph, acquire the appropriate shader
for (std::size_t i = 0; i < q3font::GLYPH_COUNT_PER_FONT; ++i)
{
TexturePathMap::const_iterator found = _textures.find(_glyphs[i]->texture);
assert(found != _textures.end());
_glyphs[i]->shader = GlobalRenderSystem().capture(found->second);
}
}
void Doom3MapCompiler::setDmapRenderOption(const cmd::ArgumentList& args)
{
if (args.size() == 0)
{
rMessage() << "Usage: setDmapRenderOption <nodeId>" << std::endl;
return;
}
if (!_debugRenderer)
{
_debugRenderer.reset(new DebugRenderer);
GlobalRenderSystem().attachRenderable(*_debugRenderer);
}
_debugRenderer->setProcFile(_procFile);
_debugRenderer->setActiveNode(args[0].getInt());
GlobalSceneGraph().sceneChanged();
}
MD5ModelNode::~MD5ModelNode() {
destroyRemaps();
GlobalRenderSystem().detach(*this);
}
MD5ModelNode::~MD5ModelNode()
{
GlobalRenderSystem().detachLitObject(*this);
}
void MapPreview::draw() {
if (_root == NULL) return;
// Create scoped sentry object to swap the GLWidget's buffers
gtkutil::GLWidgetSentry sentry(_glWidget);
// Set up the render
glClearColor(0.2f, 0.2f, 0.2f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
AABB aabb(Vector3(0,0,0), Vector3(10,10,10));
// Premultiply with the translations
glLoadIdentity();
glTranslatef(0, 0, _camDist); // camera translation
glMultMatrixd(_rotation); // post multiply with rotations
glRotatef(90, -1, 0, 0); // axis rotation (y-up (GL) -> z-up (model))
// Render the map
glEnable(GL_LIGHTING);
glTranslatef(-aabb.origin.x(), -aabb.origin.y(), -aabb.origin.z()); // model translation
// Start rendering
unsigned int globalstate =
RENDER_DEPTHTEST|RENDER_COLOURWRITE|RENDER_DEPTHWRITE|
RENDER_ALPHATEST|RENDER_BLEND|RENDER_CULLFACE|RENDER_COLOURARRAY|
RENDER_OFFSETLINE|RENDER_POLYGONSMOOTH|RENDER_LINESMOOTH|
RENDER_COLOURCHANGE;
globalstate |= RENDER_FILL | RENDER_LIGHTING | RENDER_TEXTURE_2D |
RENDER_SMOOTH | RENDER_SCALED | RENDER_BUMP | RENDER_PROGRAM | RENDER_SCREEN;
CamRenderer renderer(globalstate, _stateSelect1, _stateSelect2, Vector3(0,0,_camDist));
MapPreviewView view;
// Save the new GL matrix for GL draw
glGetDoublev(GL_MODELVIEW_MATRIX, view.modelView);
glGetDoublev(GL_PROJECTION_MATRIX, view.projection);
// Instantiate a new walker class
RenderHighlighted renderHighlightWalker(renderer, view);
// Small helper class to use scene::Graph::Walkers for direct traversal
class RenderAdaptor :
public scene::NodeVisitor
{
scene::Graph::Walker& _walker;
public:
RenderAdaptor(scene::Graph::Walker& walker) :
_walker(walker)
{}
bool pre(const scene::INodePtr& node)
{
_walker.visit(node);
return true;
}
} adaptor(renderHighlightWalker);
// Submit renderables from this map root
Node_traverseSubgraph(_root, adaptor);
// Submit renderables directly attached to the ShaderCache
RenderHighlighted walker(renderer, view);
GlobalRenderSystem().forEachRenderable(walker.getRenderableCallback());
renderer.render(view.modelView, view.projection);
}
void RadiantSelectionSystem::constructStatic() {
_state = GlobalRenderSystem().capture("$POINT");
TranslateManipulator::_stateWire = GlobalRenderSystem().capture("$WIRE_OVERLAY");
TranslateManipulator::_stateFill = GlobalRenderSystem().capture("$FLATSHADE_OVERLAY");
RotateManipulator::_stateOuter = GlobalRenderSystem().capture("$WIRE_OVERLAY");
}
void OpenGLModule::sharedContextDestroyed()
{
_font.reset();
GlobalRenderSystem().unrealise();
}
/*greebo: This is a callback function that gets connected in the constructor
* Don't know exactly what it does, but it seems to notify the shader cache that the light has moved or
* something like that.
*/
void LightNode::lightChanged() {
GlobalRenderSystem().lightChanged(*this);
}
