void View::construct () { m_viewproj = matrix4_multiplied_by_matrix4(matrix4_multiplied_by_matrix4(m_scissor, m_projection), m_modelview); m_frustum = frustum_from_viewproj(m_viewproj); m_viewer = viewer_from_viewproj(m_viewproj); }
void RotateManipulator::testSelect (const View& view, const Matrix4& pivot2world) { m_pivot.update(pivot2world, view.GetModelview(), view.GetProjection(), view.GetViewport()); updateCircleTransforms(); SelectionPool selector; { { Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_local2world_x)); SelectionIntersection best; LineStrip_BestPoint(local2view, m_circle_x.m_vertices.data(), m_circle_x.m_vertices.size(), best); selector.addSelectable(best, &m_selectable_x); } { Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_local2world_y)); SelectionIntersection best; LineStrip_BestPoint(local2view, m_circle_y.m_vertices.data(), m_circle_y.m_vertices.size(), best); selector.addSelectable(best, &m_selectable_y); } { Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_local2world_z)); SelectionIntersection best; LineStrip_BestPoint(local2view, m_circle_z.m_vertices.data(), m_circle_z.m_vertices.size(), best); selector.addSelectable(best, &m_selectable_z); } } { Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_viewpointSpace)); { SelectionIntersection best; LineLoop_BestPoint(local2view, m_circle_screen.m_vertices.data(), m_circle_screen.m_vertices.size(), best); selector.addSelectable(best, &m_selectable_screen); } { SelectionIntersection best; Circle_BestPoint(local2view, eClipCullCW, m_circle_sphere.m_vertices.data(), m_circle_sphere.m_vertices.size(), best); selector.addSelectable(best, &m_selectable_sphere); } } m_axis_screen = m_pivot.m_axis_screen; if (!selector.failed()) { (*selector.begin()).second->setSelected(true); } }
void TextureProjection::transformLocked (std::size_t width, std::size_t height, const Plane3& plane, const Matrix4& identity2transformed) { Vector3 normalTransformed(matrix4_transformed_direction(identity2transformed, plane.normal())); // identity: identity space // transformed: transformation // stIdentity: base st projection space before transformation // stTransformed: base st projection space after transformation // stOriginal: original texdef space // stTransformed2stOriginal = stTransformed -> transformed -> identity -> stIdentity -> stOriginal Matrix4 identity2stIdentity; basisForNormal(plane.normal(), identity2stIdentity); Matrix4 transformed2stTransformed; basisForNormal(normalTransformed, transformed2stTransformed); Matrix4 stTransformed2identity(matrix4_affine_inverse(matrix4_multiplied_by_matrix4(transformed2stTransformed, identity2transformed))); Vector3 originalProjectionAxis(matrix4_affine_inverse(identity2stIdentity).z().getVector3()); Vector3 transformedProjectionAxis(stTransformed2identity.z().getVector3()); Matrix4 stIdentity2stOriginal = m_texdef.getTransform((float) width, (float) height); Matrix4 identity2stOriginal(matrix4_multiplied_by_matrix4(stIdentity2stOriginal, identity2stIdentity)); double dot = originalProjectionAxis.dot(transformedProjectionAxis); if (dot == 0) { // The projection axis chosen for the transformed normal is at 90 degrees // to the transformed projection axis chosen for the original normal. // This happens when the projection axis is ambiguous - e.g. for the plane // 'X == Y' the projection axis could be either X or Y. Matrix4 identityCorrected = matrix4_reflection_for_plane45(plane, originalProjectionAxis, transformedProjectionAxis); identity2stOriginal = matrix4_multiplied_by_matrix4(identity2stOriginal, identityCorrected); } Matrix4 stTransformed2stOriginal = matrix4_multiplied_by_matrix4(identity2stOriginal, stTransformed2identity); setTransform((float) width, (float) height, stTransformed2stOriginal); m_texdef.normalise((float) width, (float) height); }
inline void matrix4_assign_rotation_for_pivot(Matrix4& matrix, scene::Instance& instance) { Editable* editable = Node_getEditable(instance.path().top()); // If the instance is editable, take the localpivot point into account, otherwise just apply the rotation if (editable != 0) { matrix4_assign_rotation(matrix, matrix4_multiplied_by_matrix4(instance.localToWorld(), editable->getLocalPivot())); } else { matrix4_assign_rotation(matrix, instance.localToWorld()); } }
void ScaleManipulator::testSelect (const View& view, const Matrix4& pivot2world) { m_pivot.update(pivot2world, view.GetModelview(), view.GetProjection(), view.GetViewport()); SelectionPool selector; { Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_worldSpace)); { SelectionIntersection best; Line_BestPoint(local2view, m_arrow_x.m_line, best); selector.addSelectable(best, &m_selectable_x); } { SelectionIntersection best; Line_BestPoint(local2view, m_arrow_y.m_line, best); selector.addSelectable(best, &m_selectable_y); } { SelectionIntersection best; Line_BestPoint(local2view, m_arrow_z.m_line, best); selector.addSelectable(best, &m_selectable_z); } } { Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_viewpointSpace)); { SelectionIntersection best; Quad_BestPoint(local2view, eClipCullCW, m_quad_screen.m_quad, best); selector.addSelectable(best, &m_selectable_screen); } } if (!selector.failed()) { (*selector.begin()).second->setSelected(true); } }
/* greebo: This is called by the ManipulateObserver class on the mouseDown event. It checks, if a manipulator * can be selected where the mouse is pointing to. */ bool RadiantSelectionSystem::SelectManipulator(const View& view, const float device_point[2], const float device_epsilon[2]) { if (!nothingSelected() || (ManipulatorMode() == eDrag && Mode() == eComponent)) { #if defined (DEBUG_SELECTION) g_render_clipped.destroy(); #endif // Unselect any currently selected manipulators to be sure _manipulator->setSelected(false); // Test, if the current manipulator can be selected if (!nothingSelected() || (ManipulatorMode() == eDrag && Mode() == eComponent)) { View scissored(view); ConstructSelectionTest(scissored, SelectionBoxForPoint(device_point, device_epsilon)); // The manipulator class checks on its own, if any of its components can be selected _manipulator->testSelect(scissored, GetPivot2World()); } // Save the pivot2world matrix startMove(); // This is true, if a manipulator could be selected _pivotMoving = _manipulator->isSelected(); // is a manipulator selected / the pivot moving? if (_pivotMoving) { Pivot2World pivot; pivot.update(GetPivot2World(), view.GetModelview(), view.GetProjection(), view.GetViewport()); _manip2pivotStart = matrix4_multiplied_by_matrix4(matrix4_full_inverse(_pivot2worldStart), pivot.m_worldSpace); Matrix4 device2manip; ConstructDevice2Manip(device2manip, _pivot2worldStart, view.GetModelview(), view.GetProjection(), view.GetViewport()); _manipulator->GetManipulatable()->Construct(device2manip, device_point[0], device_point[1]); _undoBegun = false; } SceneChangeNotify(); } return _pivotMoving; }
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 ); } }
void TranslateManipulator::testSelect (const View& view, const Matrix4& pivot2world) { m_pivot.update(pivot2world, view.GetModelview(), view.GetProjection(), view.GetViewport()); SelectionPool selector; 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); { Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_viewpointSpace)); { SelectionIntersection best; Quad_BestPoint(local2view, eClipCullCW, m_quad_screen.m_quad, best); if (best.valid()) { best = SelectionIntersection(0, 0); selector.addSelectable(best, &m_selectable_screen); } } } { Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_worldSpace)); #if defined(DEBUG_SELECTION) g_render_clipped.construct(view.GetViewMatrix()); #endif if (show_x) { SelectionIntersection best; Line_BestPoint(local2view, m_arrow_x.m_line, best); Triangles_BestPoint(local2view, eClipCullCW, m_arrow_head_x.m_vertices.begin(), m_arrow_head_x.m_vertices.end(), best); selector.addSelectable(best, &m_selectable_x); } if (show_y) { SelectionIntersection best; Line_BestPoint(local2view, m_arrow_y.m_line, best); Triangles_BestPoint(local2view, eClipCullCW, m_arrow_head_y.m_vertices.begin(), m_arrow_head_y.m_vertices.end(), best); selector.addSelectable(best, &m_selectable_y); } if (show_z) { SelectionIntersection best; Line_BestPoint(local2view, m_arrow_z.m_line, best); Triangles_BestPoint(local2view, eClipCullCW, m_arrow_head_z.m_vertices.begin(), m_arrow_head_z.m_vertices.end(), best); selector.addSelectable(best, &m_selectable_z); } } if (!selector.failed()) { (*selector.begin()).second->setSelected(true); } }
Matrix4 testMatrix4MultipliedConstant1(const Matrix4& a) { return matrix4_multiplied_by_matrix4(a, g_matrix4_identity); }
Matrix4 testMatrix4Multiplied1(const Matrix4& a, const Matrix4& b) { return matrix4_multiplied_by_matrix4(a, matrix4_multiplied_by_matrix4(a, b)); }