void CurveEditInstance::renderComponents(RenderableCollector& collector,
const VolumeTest& volume, const Matrix4& localToWorld) const
{
collector.SetState(_shaders.controlsShader, RenderableCollector::eWireframeOnly);
collector.SetState(_shaders.controlsShader, RenderableCollector::eFullMaterials);
collector.addRenderable(m_controlsRender, localToWorld);
}
void MD5Surface::render(RenderableCollector& collector, const Matrix4& localToWorld,
const ShaderPtr& shader, const IRenderEntity& entity) const
{
assert(shader); // shader must be captured at this point
collector.SetState(shader, RenderableCollector::eFullMaterials);
collector.addRenderable(*this, localToWorld, entity);
}
// Front-end renderable submission
void RenderablePicoSurface::submitRenderables(RenderableCollector& rend,
const Matrix4& localToWorld,
const ShaderPtr& shader,
const IRenderEntity& entity)
{
// Submit geometry
rend.SetState(shader, RenderableCollector::eFullMaterials);
rend.addRenderable(*this, localToWorld, entity);
}
/* greebo: Renders the currently active manipulator by setting the render state and
* calling the manipulator's render method
*/
void RadiantSelectionSystem::renderSolid(RenderableCollector& collector, const VolumeTest& volume) const {
if (!nothingSelected()) {
collector.highlightFaces(false);
collector.highlightPrimitives(false);
collector.SetState(_state, RenderableCollector::eWireframeOnly);
collector.SetState(_state, RenderableCollector::eFullMaterials);
_manipulator->render(collector, volume, GetPivot2World());
}
}
void CurveEditInstance::renderComponentsSelected(RenderableCollector& collector,
const VolumeTest& volume, const Matrix4& localToWorld) const
{
updateSelected();
if(!m_selectedRender.empty())
{
collector.highlightPrimitives(false);
collector.SetState(_shaders.selectedShader, RenderableCollector::eWireframeOnly);
collector.SetState(_shaders.selectedShader, RenderableCollector::eFullMaterials);
collector.addRenderable(m_selectedRender, localToWorld);
}
}
void MD5ModelNode::render(RenderableCollector& collector, const VolumeTest& volume,
const Matrix4& localToWorld, const IRenderEntity& entity) const
{
// Do some rough culling (per model, not per surface)
if (volume.TestAABB(localAABB(), localToWorld) == VOLUME_OUTSIDE)
{
return;
}
SurfaceLightLists::const_iterator j = _surfaceLightLists.begin();
// greebo: Iterate over all MD5 surfaces and render them
for (MD5Model::const_iterator i = _model->begin();
i != _model->end();
++i, ++j)
{
assert(i->shader);
// Get the Material to test the shader name against the filter system
const MaterialPtr& surfaceShader = i->shader->getMaterial();
if (surfaceShader->isVisible())
{
collector.setLights(*j);
i->surface->render(collector, localToWorld, i->shader, entity);
}
}
// Uncomment to render the skeleton
//collector.SetState(entity.getWireShader(), RenderableCollector::eFullMaterials);
//collector.addRenderable(_model->getRenderableSkeleton(), localToWorld, entity);
}
// Submit renderable geometry
void FaceInstance::submitRenderables(RenderableCollector& collector,
const VolumeTest& volume,
const IRenderEntity& entity) const
{
if (m_face->intersectVolume(volume))
{
collector.PushState();
if (selectedComponents())
{
collector.highlightFaces(true);
}
m_face->submitRenderables(collector, Matrix4::getIdentity(), entity);
collector.PopState();
}
}
void EclassModel::renderSolid(RenderableCollector& collector,
const VolumeTest& volume, const Matrix4& localToWorld, bool selected) const
{
if(selected) {
m_renderOrigin.render(collector, volume, localToWorld);
}
collector.SetState(m_entity.getEntityClass()->getWireShader(), RenderableCollector::eWireframeOnly);
}
void TranslateManipulator::render(RenderableCollector& collector, const VolumeTest& volume, const Matrix4& pivot2world) {
_pivot.update(pivot2world, volume.GetModelview(), volume.GetProjection(), volume.GetViewport());
// temp hack
UpdateColours();
Vector3 x = _pivot._worldSpace.x().getVector3().getNormalised();
bool show_x = manipulator_show_axis(_pivot, x);
Vector3 y = _pivot._worldSpace.y().getVector3().getNormalised();
bool show_y = manipulator_show_axis(_pivot, y);
Vector3 z = _pivot._worldSpace.z().getVector3().getNormalised();
bool show_z = manipulator_show_axis(_pivot, z);
collector.SetState(_stateWire, RenderableCollector::eWireframeOnly);
collector.SetState(_stateWire, RenderableCollector::eFullMaterials);
if(show_x)
{
collector.addRenderable(_arrowX, _pivot._worldSpace);
}
if(show_y)
{
collector.addRenderable(_arrowY, _pivot._worldSpace);
}
if(show_z)
{
collector.addRenderable(_arrowZ, _pivot._worldSpace);
}
collector.addRenderable(_quadScreen, _pivot._viewplaneSpace);
collector.SetState(_stateFill, RenderableCollector::eWireframeOnly);
collector.SetState(_stateFill, RenderableCollector::eFullMaterials);
if(show_x)
{
collector.addRenderable(_arrowHeadX, _pivot._worldSpace);
}
if(show_y)
{
collector.addRenderable(_arrowHeadY, _pivot._worldSpace);
}
if(show_z)
{
collector.addRenderable(_arrowHeadZ, _pivot._worldSpace);
}
}
// Renderable submission
void PicoModelNode::submitRenderables(RenderableCollector& collector,
const VolumeTest& volume,
const Matrix4& localToWorld,
const IRenderEntity& entity) const
{
// Test the model's intersection volume, if it intersects pass on the
// render call
if (volume.TestAABB(_picoModel->localAABB(), localToWorld) != VOLUME_OUTSIDE)
{
// Submit the lights
collector.setLights(_lights);
// Submit the model's geometry
_picoModel->submitRenderables(collector, localToWorld, entity);
}
}
void MD5ModelNode::render(RenderableCollector& collector, const VolumeTest& volume,
const Matrix4& localToWorld) const
{
// Do some rough culling (per model, not per surface)
if (volume.TestAABB(localAABB(), localToWorld) == VOLUME_OUTSIDE)
{
return;
}
SurfaceLightLists::const_iterator j = _surfaceLightLists.begin();
SurfaceRemaps::const_iterator k = _surfaceRemaps.begin();
// greebo: Iterate over all MD5 surfaces and render them
for (MD5Model::const_iterator i = _model->begin();
i != _model->end();
++i, ++j, ++k)
{
collector.setLights(*j);
(*i)->render(collector, localToWorld, k->shader != NULL ? k->shader : (*i)->getState());
}
}
void Doom3Group::renderSolid(RenderableCollector& collector, const VolumeTest& volume,
const Matrix4& localToWorld, bool selected) const
{
if (selected) {
m_renderOrigin.render(collector, volume, localToWorld);
}
collector.SetState(_entity.getEntityClass()->getWireShader(), RenderableCollector::eWireframeOnly);
collector.SetState(_entity.getEntityClass()->getWireShader(), RenderableCollector::eFullMaterials);
if (!m_curveNURBS.isEmpty())
{
// Always render curves relative to map origin
m_curveNURBS.renderSolid(collector, volume, Matrix4::getIdentity());
}
if (!m_curveCatmullRom.isEmpty())
{
// Always render curves relative to map origin
m_curveCatmullRom.renderSolid(collector, volume, Matrix4::getIdentity());
}
}
void NullModel::renderWireframe(RenderableCollector& collector,
const VolumeTest& volume, const Matrix4& localToWorld) const
{
collector.SetState(_state, RenderableCollector::eWireframeOnly);
collector.addRenderable(_aabbWire, localToWorld);
}
void NullModel::renderSolid(RenderableCollector& collector,
const VolumeTest& volume, const Matrix4& localToWorld) const
{
collector.SetState(_state, RenderableCollector::eFullMaterials);
collector.addRenderable(_aabbSolid, localToWorld);
}
