void renderWireframe(Renderer& renderer, const VolumeTest& volume) const { m_contained.renderWireframe(renderer, volume, Instance::localToWorld(), getSelectable().isSelected()); m_curveNURBS.renderComponentsSelected(renderer, volume, localToWorld()); m_curveCatmullRom.renderComponentsSelected(renderer, volume, localToWorld()); }
void LightNode::renderInactiveComponents(RenderableCollector& collector, const VolumeTest& volume, const bool selected) const { // greebo: We are not in component selection mode (and the light is still selected), // check if we should draw the center of the light anyway if (selected && GlobalSelectionSystem().ComponentMode() != SelectionSystem::eVertex && EntitySettings::InstancePtr()->alwaysShowLightVertices()) { if (_light.isProjected()) { EntitySettings& settings = *EntitySettings::InstancePtr(); const Vector3& colourStartEndInactive = settings.getLightVertexColour(EntitySettings::VERTEX_START_END_DESELECTED); const Vector3& colourVertexInactive = settings.getLightVertexColour(EntitySettings::VERTEX_DESELECTED); const_cast<Light&>(_light).colourLightStart() = colourStartEndInactive; const_cast<Light&>(_light).colourLightEnd() = colourStartEndInactive; const_cast<Light&>(_light).colourLightTarget() = colourVertexInactive; const_cast<Light&>(_light).colourLightRight() = colourVertexInactive; const_cast<Light&>(_light).colourLightUp() = colourVertexInactive; // Render the projection points _light.renderProjectionPoints(collector, volume, localToWorld()); } else { const Vector3& colourVertexInactive = EntitySettings::InstancePtr()->getLightVertexColour( EntitySettings::VERTEX_INACTIVE); const_cast<Light&>(_light).getDoom3Radius().setCenterColour(colourVertexInactive); _light.renderLightCentre(collector, volume, localToWorld()); } } }
// Function checks if a point is inside a polygon using the point-polygon // collision detection discussed in class unsigned int pointPolygonCollide(object *o, vector *v) { // cols = number of edge collisions int cols = 0, i; vector *pv = o->verts; vector v1, v2; // iterate through all polygon vertices for (i = 0; i < o->size-1; i++) { v1 = localToWorld(pv+i, o); v2 = localToWorld(pv+i+1, o); // Ensure v1.y < v.y < v2.y or skip this edge if (v->y > v1.y && v->y < v2.y) { } else if (v->y < v1.y && v->y > v2.y) { v1 = v2; v2 = localToWorld(pv+i, o); } else continue; // Ensure the edge is to the right of v and if so, increment cols if ((v->y - v1.y) / (v2.y - v1.y) * v2.x + (v2.y - v->y) / (v2.y - v1.y) * v1.x > v->x) { cols++; } } // If there is an odd number of collisions return true, else return false return cols%2; }
void renderComponents(Renderer& renderer, const VolumeTest& volume) const { if(GlobalSelectionSystem().ComponentMode() == SelectionSystem::eVertex) { m_curveNURBS.renderComponents(renderer, volume, localToWorld()); m_curveCatmullRom.renderComponents(renderer, volume, localToWorld()); } }
void RotateGizmoRing::render(IViewer* viewer) const { GraphicsInterface::beginPerformanceEvent("Ring"); GraphicsInterface::resetRenderTarget(true); GraphicsInterface::setViewport(GraphicsInterface::backBufferSize()); GraphicsInterface::setBlendState(IGraphicsInterface::NOBLEND); GraphicsInterface::setRenderState(CULL_MODE_NONE, true); if (drawBounds_) { effect_->beginDraw(); BoundingBox bounds = boundingBox(); Vector4 scale(bounds.max.x - bounds.min.x, bounds.max.y - bounds.min.y, bounds.max.z - bounds.min.z, 2.0f); scale /= 2.0f; Vector4 translation(bounds.max.x + bounds.min.x, bounds.max.y + bounds.min.y, bounds.max.z + bounds.min.z, 2.0f); translation /= 2.0f; Matrix4x4 model = localToWorld() * Matrix4x4::translation(translation) * Matrix4x4::scale(scale); Matrix4x4 modelViewProjection = viewer->projection() * viewer->viewTransform() * model * Matrix4x4::scale(1.0001f); effect_->setUniform(modelViewProjection, "ModelViewProj"); effect_->setUniform(ringColor_, "Color"); effect_->commitBuffers(); GraphicsInterface::drawVertexBuffer(Geometry::UNIT_CUBE_VERTEX_BUFFER, Geometry::UNIT_CUBE_VERTEX_COUNT, Geometry::UNIT_CUBE_VERTEX_FORMAT); effect_->endDraw(); } // ring { effect_->beginDraw(); Color3 color = ringColor_; if (isHighlighted_) { color = Color3::YELLOW; } effect_->setUniform(color, "Color"); Matrix4x4 modelViewProjection = viewer->projection() * viewer->viewTransform() * localToWorld(); effect_->setUniform(modelViewProjection, "ModelViewProj"); Matrix4x4 model = localToWorld(); effect_->setUniform(model, "Model"); effect_->commitBuffers(); GraphicsInterface::drawVertexBuffer(Geometry::UNIT_CIRCLE_VERTEX_BUFFER, Geometry::UNIT_CIRCLE_VERTEX_COUNT, Geometry::UNIT_CIRCLE_VERTEX_FORMAT); effect_->endDraw(); } GraphicsInterface::endPerformanceEvent(); }
void Node::evaluateBounds() const { if (_boundsChanged) { ASSERT_MESSAGE(!_boundsMutex, "re-entering bounds evaluation"); _boundsMutex = true; _bounds = childBounds(); _bounds.includeAABB( AABB::createFromOrientedAABBSafe(localAABB(), localToWorld()) ); _boundsMutex = false; _boundsChanged = false; // Now that our bounds are re-calculated, notify the scenegraph GraphPtr sceneGraph = _sceneGraph.lock(); if (sceneGraph) { sceneGraph->nodeBoundsChanged(const_cast<Node*>(this)->shared_from_this()); } } }
void BrushInstance::testSelectComponents (Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode) { test.BeginMesh(localToWorld()); switch (mode) { case SelectionSystem::eVertex: { for (VertexInstances::iterator i = m_vertexInstances.begin(); i != m_vertexInstances.end(); ++i) { (*i).testSelect(selector, test); } } break; case SelectionSystem::eEdge: { for (EdgeInstances::iterator i = m_edgeInstances.begin(); i != m_edgeInstances.end(); ++i) { (*i).testSelect(selector, test); } } break; case SelectionSystem::eFace: { if (test.getVolume().fill()) { for (FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i) { (*i).testSelect(selector, test); } } else { for (FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i) { (*i).testSelect_centroid(selector, test); } } } break; default: break; } }
void GLMatrix::Rotate(const GLVertex3 & pivot, const GLVector3 & axis, double angle) { // Update martix so resulting transform has been rotated about 'pivot' // (in parent frame), round vector 'axis', through 'angle' (radians) // Equivalent to glRotate function, but with addition of translation // and compounded on top of existing. GLVector3 nAxis = axis; nAxis.Normalise(); double x = nAxis.X(); double y = nAxis.Y(); double z = nAxis.Z(); double c = TMath::Cos(angle); double s = TMath::Sin(angle); // Calculate local rotation, with pre-translation to local pivot origin GLMatrix rotMat; rotMat[ 0] = x*x*(1-c) + c; rotMat[ 4] = x*y*(1-c) - z*s; rotMat[ 8] = x*z*(1-c) + y*s; rotMat[12] = pivot[0]; rotMat[ 1] = y*x*(1-c) + z*s; rotMat[ 5] = y*y*(1-c) + c; rotMat[ 9] = y*z*(1-c) - x*s; rotMat[13] = pivot[1]; rotMat[ 2] = x*z*(1-c) - y*s; rotMat[ 6] = y*z*(1-c) + x*s; rotMat[10] = z*z*(1-c) + c; rotMat[14] = pivot[2]; rotMat[ 3] = 0.0; rotMat[ 7] = 0.0; rotMat[11] = 0.0; rotMat[15] = 1.0; GLMatrix localToWorld(-pivot); // TODO: Ugly - should use quaternions to avoid compound rounding errors and // triple multiplication *this = rotMat * localToWorld * (*this); }
GfMatrix4d UsdGeomConstraintTarget::ComputeInWorldSpace( UsdTimeCode time, UsdGeomXformCache *xfCache) const { if (not IsDefined()) { TF_CODING_ERROR("Invalid constraint target."); return GfMatrix4d(1); } const UsdPrim &modelPrim = GetAttr().GetPrim(); GfMatrix4d localToWorld(1); if (xfCache) { xfCache->SetTime(time); localToWorld = xfCache->GetLocalToWorldTransform(modelPrim); } else { UsdGeomXformCache cache; cache.SetTime(time); localToWorld = cache.GetLocalToWorldTransform(modelPrim); } GfMatrix4d localConstraintSpace(1.); if (not Get(&localConstraintSpace, time)) { TF_WARN("Failed to get value of constraint target '%s' at path <%s>.", GetIdentifier().GetText(), GetAttr().GetPath().GetText()); return localConstraintSpace; } return localConstraintSpace * localToWorld; }
// Renders the components of this light instance void LightNode::renderComponents(RenderableCollector& collector, const VolumeTest& volume) const { // Render the components (light center) as selected/deselected, if we are in the according mode if (GlobalSelectionSystem().ComponentMode() == SelectionSystem::eVertex) { if (_light.isProjected()) { // A projected light EntitySettings& settings = *EntitySettings::InstancePtr(); const Vector3& colourStartEndSelected = settings.getLightVertexColour(EntitySettings::VERTEX_START_END_SELECTED); const Vector3& colourStartEndDeselected = settings.getLightVertexColour(EntitySettings::VERTEX_START_END_DESELECTED); const Vector3& colourVertexSelected = settings.getLightVertexColour(EntitySettings::VERTEX_SELECTED); const Vector3& colourVertexDeselected = settings.getLightVertexColour(EntitySettings::VERTEX_DESELECTED); // Update the colour of the light center dot const_cast<Light&>(_light).colourLightTarget() = (_lightTargetInstance.isSelected()) ? colourVertexSelected : colourVertexDeselected; const_cast<Light&>(_light).colourLightRight() = (_lightRightInstance.isSelected()) ? colourVertexSelected : colourVertexDeselected; const_cast<Light&>(_light).colourLightUp() = (_lightUpInstance.isSelected()) ? colourVertexSelected : colourVertexDeselected; const_cast<Light&>(_light).colourLightStart() = (_lightStartInstance.isSelected()) ? colourStartEndSelected : colourStartEndDeselected; const_cast<Light&>(_light).colourLightEnd() = (_lightEndInstance.isSelected()) ? colourStartEndSelected : colourStartEndDeselected; // Render the projection points _light.renderProjectionPoints(collector, volume, localToWorld()); } else { // A point light // Update the colour of the light center dot if (_lightCenterInstance.isSelected()) { const_cast<Light&>(_light).getDoom3Radius().setCenterColour( EntitySettings::InstancePtr()->getLightVertexColour(EntitySettings::VERTEX_SELECTED)); _light.renderLightCentre(collector, volume, localToWorld()); } else { const_cast<Light&>(_light).getDoom3Radius().setCenterColour( EntitySettings::InstancePtr()->getLightVertexColour(EntitySettings::VERTEX_DESELECTED)); _light.renderLightCentre(collector, volume, localToWorld()); } } } }
void MD5ModelNode::renderSolid(RenderableCollector& collector, const VolumeTest& volume) const { _lightList->calculateIntersectingLights(); assert(_renderEntity); render(collector, volume, localToWorld(), *_renderEntity); }
void BrushInstance::renderWireframe (Renderer& renderer, const VolumeTest& volume) const { m_brush.evaluateBRep(); renderClipPlane(renderer, volume); renderWireframe(renderer, volume, localToWorld()); }
void EclassModelNode::renderWireframe(RenderableCollector& collector, const VolumeTest& volume) const { EntityNode::renderWireframe(collector, volume); if (isSelected()) { _renderOrigin.render(collector, volume, localToWorld()); } }
void Doom3GroupNode::renderWireframe(RenderableCollector& collector, const VolumeTest& volume) const { EntityNode::renderWireframe(collector, volume); _d3Group.renderWireframe(collector, volume, localToWorld(), isSelected()); _nurbsEditInstance.renderComponentsSelected(collector, volume, Matrix4::getIdentity()); _catmullRomEditInstance.renderComponentsSelected(collector, volume, Matrix4::getIdentity()); }
void Doom3GroupNode::renderWireframe(RenderableCollector& collector, const VolumeTest& volume) const { EntityNode::renderWireframe(collector, volume); m_contained.renderWireframe(collector, volume, localToWorld(), isSelected()); m_curveNURBS.renderComponentsSelected(collector, volume, Matrix4::getIdentity()); m_curveCatmullRom.renderComponentsSelected(collector, volume, Matrix4::getIdentity()); }
void testSelectComponents(Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode) { if(mode == SelectionSystem::eVertex) { test.BeginMesh(localToWorld()); m_curveNURBS.testSelect(selector, test); m_curveCatmullRom.testSelect(selector, test); } }
void MD5ModelNode::insertLight(const RendererLight& light) { const Matrix4& l2w = localToWorld(); _surfaceLightLists.resize(_model->size()); SurfaceLightLists::iterator j = _surfaceLightLists.begin(); for (MD5Model::const_iterator i = _model->begin(); i != _model->end(); ++i) { Surface_addLight(*i->surface, *j++, l2w, light); } }
void Doom3GroupNode::renderSolid(RenderableCollector& collector, const VolumeTest& volume) const { EntityNode::renderSolid(collector, volume); _d3Group.renderSolid(collector, volume, localToWorld(), isSelected()); // Render curves always relative to the absolute map origin _nurbsEditInstance.renderComponentsSelected(collector, volume, Matrix4::getIdentity()); _catmullRomEditInstance.renderComponentsSelected(collector, volume, Matrix4::getIdentity()); }
void LightNode::renderWireframe(RenderableCollector& collector, const VolumeTest& volume) const { EntityNode::renderWireframe(collector, volume); const bool lightIsSelected = isSelected(); _light.renderWireframe( collector, volume, localToWorld(), lightIsSelected ); renderInactiveComponents(collector, volume, lightIsSelected); }
void BrushInstance::testSelect (Selector& selector, SelectionTest& test) { test.BeginMesh(localToWorld()); SelectionIntersection best; for (FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i) { (*i).testSelect(test, best); } if (best.valid()) { selector.addIntersection(best); } }
void Doom3GroupNode::testSelectComponents(Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode) { if (mode == SelectionSystem::eVertex) { test.BeginMesh(localToWorld()); _originInstance.testSelect(selector, test); _nurbsEditInstance.testSelect(selector, test); _catmullRomEditInstance.testSelect(selector, test); } }
// Add a light to this model instance void PicoModelNode::insertLight(const RendererLight& light) { // Calculate transform from the superclass const Matrix4& l2w = localToWorld(); // If the light's AABB intersects the oriented AABB of this model instance, // add the light to our light list if (light.intersectsAABB(AABB::createFromOrientedAABB(_picoModel->localAABB(), l2w))) { _lights.addLight(light); } }
void testSelect(Selector& selector, SelectionTest& test) { test.BeginMesh(localToWorld()); SelectionIntersection best; m_contained.testSelect(selector, test, best); if(best.valid()) { Selector_add(selector, getSelectable(), best); } }
KRNode::LodVisibility KRLODGroup::calcLODVisibility(const KRViewport &viewport) { if(m_min_distance == 0 && m_max_distance == 0) { return LOD_VISIBILITY_VISIBLE; } else { float lod_bias = viewport.getLODBias(); lod_bias = pow(2.0f, -lod_bias); // Compare using squared distances as sqrt is expensive float sqr_distance; float sqr_prestream_distance; KRVector3 world_camera_position = viewport.getCameraPosition(); KRVector3 local_camera_position = worldToLocal(world_camera_position); KRVector3 local_reference_point = m_reference.nearestPoint(local_camera_position); if(m_use_world_units) { KRVector3 world_reference_point = localToWorld(local_reference_point); sqr_distance = (world_camera_position - world_reference_point).sqrMagnitude() * (lod_bias * lod_bias); sqr_prestream_distance = getContext().KRENGINE_PRESTREAM_DISTANCE * getContext().KRENGINE_PRESTREAM_DISTANCE; } else { sqr_distance = (local_camera_position - local_reference_point).sqrMagnitude() * (lod_bias * lod_bias); KRVector3 world_reference_point = localToWorld(local_reference_point); sqr_prestream_distance = worldToLocal(KRVector3::Normalize(world_reference_point - world_camera_position) * getContext().KRENGINE_PRESTREAM_DISTANCE).sqrMagnitude(); // TODO, FINDME - Optimize with precalc? } float sqr_min_visible_distance = m_min_distance * m_min_distance; float sqr_max_visible_distance = m_max_distance * m_max_distance; if((sqr_distance >= sqr_min_visible_distance || m_min_distance == 0) && (sqr_distance < sqr_max_visible_distance || m_max_distance == 0)) { return LOD_VISIBILITY_VISIBLE; } else if((sqr_distance >= sqr_min_visible_distance - sqr_prestream_distance || m_min_distance == 0) && (sqr_distance < sqr_max_visible_distance + sqr_prestream_distance || m_max_distance == 0)) { return LOD_VISIBILITY_PRESTREAM; } else { return LOD_VISIBILITY_HIDDEN; } } }
void Doom3GroupNode::testSelect(Selector& selector, SelectionTest& test) { test.BeginMesh(localToWorld()); SelectionIntersection best; // Pass the selection test to the Doom3Group class m_contained.testSelect(selector, test, best); // If the selectionIntersection is non-empty, add the selectable to the SelectionPool if (best.valid()) { Selector_add(selector, getSelectable(), best); } }
void Doom3GroupNode::renderComponents(RenderableCollector& collector, const VolumeTest& volume) const { if (GlobalSelectionSystem().ComponentMode() == SelectionSystem::eVertex) { _nurbsEditInstance.renderComponents(collector, volume, Matrix4::getIdentity()); _catmullRomEditInstance.renderComponents(collector, volume, Matrix4::getIdentity()); // Register the renderable with OpenGL if (!_d3Group.isModel()) { _originInstance.render(collector, volume, localToWorld()); } } }
void BrushInstance::selectPlanes (Selector& selector, SelectionTest& test, const PlaneCallback& selectedPlaneCallback) { test.BeginMesh(localToWorld()); PlanePointer brushPlanes[c_brush_maxFaces]; PlanesIterator j = brushPlanes; for (Brush::const_iterator i = m_brush.begin(); i != m_brush.end(); ++i) { *j++ = &(*i)->plane3(); } for (FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i) { (*i).selectPlane(selector, Line(test.getNear(), test.getFar()), brushPlanes, j, selectedPlaneCallback); } }
//Index to... void GridMapping::indexToWorld(int i,int j,int k, double &w_x, double &w_y,double &w_z) const{ double l_x,l_y,l_z; indexToLocal(i, j, k, l_x, l_y, l_z); localToWorld(l_x, l_y, l_z, w_x, w_y, w_z); /* l_x = ((double)i)/((double)xdim()); l_y = ((double)j)/((double)ydim()); l_z = ((double)k)/((double)zdim()); w_x = l_x*_trans[0][0]+l_y*_trans[1][0]+l_z*_trans[2][0]+_trans[3][0]; w_y = l_x*_trans[0][1]+l_y*_trans[1][1]+l_z*_trans[2][1]+_trans[3][1]; w_z = l_x*_trans[0][2]+l_y*_trans[1][2]+l_z*_trans[2][2]+_trans[3][2]; */ }
void Node::evaluateBounds() const { if (_boundsChanged) { ASSERT_MESSAGE(!_boundsMutex, "re-entering bounds evaluation"); _boundsMutex = true; _bounds = childBounds(); _bounds.includeAABB( aabb_for_oriented_aabb_safe(localAABB(), localToWorld()) ); _boundsMutex = false; _boundsChanged = false; // Now that our bounds are re-calculated, notify the scenegraph GlobalSceneGraph().nodeBoundsChanged(const_cast<Node*>(this)->shared_from_this()); } }
void Doom3GroupNode::renderSolid(RenderableCollector& collector, const VolumeTest& volume) const { EntityNode::renderSolid(collector, volume); // greebo: Check if the skin needs updating before rendering. if (_updateSkin) { if (m_contained.isModel()) { // Instantiate a walker class equipped with the new value SkinChangedWalker walker(_entity.getKeyValue("skin")); // Update all children traverse(walker); } _updateSkin = false; } m_contained.renderSolid(collector, volume, localToWorld(), isSelected()); // Render curves always relative to the absolute map origin m_curveNURBS.renderComponentsSelected(collector, volume, Matrix4::getIdentity()); m_curveCatmullRom.renderComponentsSelected(collector, volume, Matrix4::getIdentity()); }