void ScaleManipulator::render (Renderer& renderer, const VolumeTest& volume, const Matrix4& pivot2world)
{
m_pivot.update(pivot2world, volume.GetModelview(), volume.GetProjection(), volume.GetViewport());
// temp hack
UpdateColours();
renderer.addRenderable(m_arrow_x, m_pivot.m_worldSpace);
renderer.addRenderable(m_arrow_y, m_pivot.m_worldSpace);
renderer.addRenderable(m_arrow_z, m_pivot.m_worldSpace);
renderer.addRenderable(m_quad_screen, m_pivot.m_viewpointSpace);
}
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);
}
}
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);
}
void TranslateManipulator::render (Renderer& renderer, const VolumeTest& volume, const Matrix4& pivot2world)
{
m_pivot.update(pivot2world, volume.GetModelview(), volume.GetProjection(), volume.GetViewport());
// temp hack
UpdateColours();
Vector3 x = m_pivot.m_worldSpace.x().getVector3().getNormalised();
bool show_x = manipulator_show_axis(m_pivot, x);
Vector3 y = m_pivot.m_worldSpace.y().getVector3().getNormalised();
bool show_y = manipulator_show_axis(m_pivot, y);
Vector3 z = m_pivot.m_worldSpace.z().getVector3().getNormalised();
bool show_z = manipulator_show_axis(m_pivot, z);
renderer.SetState(m_state_wire, Renderer::eWireframeOnly);
renderer.SetState(m_state_wire, Renderer::eFullMaterials);
if (show_x) {
renderer.addRenderable(m_arrow_x, m_pivot.m_worldSpace);
}
if (show_y) {
renderer.addRenderable(m_arrow_y, m_pivot.m_worldSpace);
}
if (show_z) {
renderer.addRenderable(m_arrow_z, m_pivot.m_worldSpace);
}
renderer.addRenderable(m_quad_screen, m_pivot.m_viewplaneSpace);
renderer.SetState(m_state_fill, Renderer::eWireframeOnly);
renderer.SetState(m_state_fill, Renderer::eFullMaterials);
if (show_x) {
renderer.addRenderable(m_arrow_head_x, m_pivot.m_worldSpace);
}
if (show_y) {
renderer.addRenderable(m_arrow_head_y, m_pivot.m_worldSpace);
}
if (show_z) {
renderer.addRenderable(m_arrow_head_z, m_pivot.m_worldSpace);
}
}
void RotateManipulator::render (Renderer& renderer, const VolumeTest& volume, const Matrix4& pivot2world)
{
m_pivot.update(pivot2world, volume.GetModelview(), volume.GetProjection(), volume.GetViewport());
updateCircleTransforms();
// temp hack
UpdateColours();
renderer.SetState(m_state_outer, Renderer::eWireframeOnly);
renderer.SetState(m_state_outer, Renderer::eFullMaterials);
renderer.addRenderable(m_circle_screen, m_pivot.m_viewpointSpace);
renderer.addRenderable(m_circle_sphere, m_pivot.m_viewpointSpace);
if (m_circle_x_visible) {
renderer.addRenderable(m_circle_x, m_local2world_x);
}
if (m_circle_y_visible) {
renderer.addRenderable(m_circle_y, m_local2world_y);
}
if (m_circle_z_visible) {
renderer.addRenderable(m_circle_z, m_local2world_z);
}
}
void BrushInstance::renderComponents (Renderer& renderer, const VolumeTest& volume) const
{
m_brush.evaluateBRep();
const Matrix4& localToWorld = Instance::localToWorld();
renderer.SetState(m_brush.m_state_point, Renderer::eWireframeOnly);
renderer.SetState(m_brush.m_state_point, Renderer::eFullMaterials);
if (volume.fill() && GlobalSelectionSystem().ComponentMode() == SelectionSystem::eFace) {
evaluateViewDependent(volume, localToWorld);
renderer.addRenderable(m_render_faces_wireframe, localToWorld);
} else {
m_brush.renderComponents(GlobalSelectionSystem().ComponentMode(), renderer, volume, localToWorld);
}
}
// 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);
}
}
bool SceneGraph::foreachNodeInVolume_r(const ISPNode& node, const VolumeTest& volume,
const INode::VisitorFunc& functor, bool visitHidden)
{
_visitedSPNodes++;
// Visit all members
const ISPNode::MemberList& members = node.getMembers();
for (ISPNode::MemberList::const_iterator m = members.begin();
m != members.end(); /* in-loop increment */)
{
// Skip hidden nodes, if specified
if (!visitHidden && !(*m)->visible())
{
++m;
continue;
}
// We're done, as soon as the walker returns FALSE
if (!functor(*m++))
{
return false;
}
}
// Now consider the children
const ISPNode::NodeList& children = node.getChildNodes();
for (ISPNode::NodeList::const_iterator i = children.begin(); i != children.end(); ++i)
{
if (volume.TestAABB((*i)->getBounds()) == VOLUME_OUTSIDE)
{
// Skip this node, not visible
_skippedSPNodes++;
continue;
}
// Traverse all the children too, enter recursion
if (!foreachNodeInVolume_r(**i, volume, functor, visitHidden))
{
// The walker returned false somewhere in the recursion depths, propagate this message
return false;
}
}
return true; // continue traversal
}
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 CPortalsRender::renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
if ( !portals.show_3d || portals.portal_count < 1 ) {
return;
}
CubicClipVolume clip = calculateCubicClipVolume( matrix4_multiplied_by_matrix4( volume.GetProjection(), volume.GetModelview() ) );
if ( portals.polygons ) {
renderer.SetState( g_shader_solid, Renderer::eWireframeOnly );
renderer.SetState( g_shader_solid, Renderer::eFullMaterials );
m_drawSolid.clip = clip;
renderer.addRenderable( m_drawSolid, g_matrix4_identity );
}
if ( portals.lines ) {
renderer.SetState( g_shader_solid_outline, Renderer::eWireframeOnly );
renderer.SetState( g_shader_solid_outline, Renderer::eFullMaterials );
m_drawSolidOutline.clip = clip;
renderer.addRenderable( m_drawSolidOutline, g_matrix4_identity );
}
}
VolumeIntersectionValue intersectVolume (const VolumeTest& volume, const Matrix4& localToWorld) const
{
return volume.TestAABB(m_aabb_local, localToWorld);
}
VolumeIntersectionValue RenderablePicoModel::intersectVolume (const VolumeTest& test, const Matrix4& localToWorld) const
{
return test.TestAABB(_localAABB, localToWorld);
}
VolumeIntersectionValue MiscParticle::intersectVolume (const VolumeTest& volume, const Matrix4& localToWorld) const
{
return volume.TestAABB(localAABB(), localToWorld);
}
