void FaceInstance::testSelect(Selector& selector, SelectionTest& test) {
SelectionIntersection best;
testSelect(test, best);
if (best.valid()) {
Selector_add(selector, m_selectable, best);
}
}
void FaceInstance::testSelect_centroid(Selector& selector, SelectionTest& test) {
if (m_face->contributes()) {
SelectionIntersection best;
m_face->testSelect_centroid(test, best);
if (best.valid()) {
Selector_add(selector, m_selectable, best);
}
}
}
void NullModel::testSelect(Selector& selector, SelectionTest& test, const Matrix4& localToWorld) {
test.BeginMesh(localToWorld);
SelectionIntersection best;
aabb_testselect(_aabbLocal, test, best);
if(best.valid()) {
selector.addIntersection(best);
}
}
void MiscParticle::testSelect (Selector& selector, SelectionTest& test, const Matrix4& localToWorld)
{
test.BeginMesh(localToWorld);
SelectionIntersection best;
aabb_testselect(m_aabb_local, test, best);
if (best.valid()) {
selector.addIntersection(best);
}
}
void BestPoint(std::size_t count, Vector4 clipped[9], SelectionIntersection& best, clipcull_t cull) {
Vector3 normalised[9];
{
for(std::size_t i=0; i<count; ++i)
{
normalised[i][0] = clipped[i][0] / clipped[i][3];
normalised[i][1] = clipped[i][1] / clipped[i][3];
normalised[i][2] = clipped[i][2] / clipped[i][3];
}
}
if(cull != eClipCullNone && count > 2)
{
double signed_area = triangle_signed_area_XY(normalised[0], normalised[1], normalised[2]);
if((cull == eClipCullCW && signed_area > 0)
|| (cull == eClipCullCCW && signed_area < 0))
return;
}
if(count == 2)
{
Segment3D segment(normalised[0], normalised[1]);
Point3D point = segment_closest_point_to_point(segment, Vector3(0, 0, 0));
best.assignIfCloser(SelectionIntersection(point.z(), 0));
}
else if(count > 2 && !point_test_polygon_2d(Vector3(0, 0, 0), normalised, normalised + count))
{
point_iterator_t end = normalised + count;
for(point_iterator_t previous = end-1, current = normalised; current != end; previous = current, ++current)
{
Segment3D segment(*previous, *current);
Point3D point = segment_closest_point_to_point(segment, Vector3(0, 0, 0));
double depth = point.z();
point.z() = 0;
double distance = point.getLengthSquared();
best.assignIfCloser(SelectionIntersection(depth, distance));
}
}
else if(count > 2)
{
best.assignIfCloser(
SelectionIntersection(
static_cast<float>(
Ray(Vector3(0, 0, 0), Vector3(0, 0, 1)).getDistance(
Plane3(normalised[0], normalised[1], normalised[2])
)),
0
)
);
}
}
void Face_getClosest(Face& face, SelectionTest& test, SelectionIntersection& bestIntersection, Face*& closestFace)
{
SelectionIntersection intersection;
face.testSelect(test, intersection);
if(intersection.valid()
&& SelectionIntersection_closer(intersection, bestIntersection))
{
bestIntersection = intersection;
closestFace = &face;
}
}
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 testSelect(Selector& selector, SelectionTest& test)
{
test.BeginMesh(localToWorld());
SelectionIntersection best;
m_contained.testSelect(selector, test, best);
if(best.valid())
{
Selector_add(selector, getSelectable(), best);
}
}
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 CurveEditInstance::testSelect(Selector& selector, SelectionTest& test)
{
ASSERT_MESSAGE(_controlPointsTransformed.size() == _selectables.size(), "curve instance mismatch");
ControlPoints::const_iterator p = _controlPointsTransformed.begin();
for(Selectables::iterator i = _selectables.begin(); i != _selectables.end(); ++i, ++p)
{
SelectionIntersection best;
test.TestPoint(*p, best);
if (best.valid())
{
Selector_add(selector, *i, best);
}
}
}
// Selection test
void MD5Surface::testSelect(Selector& selector,
SelectionTest& test,
const Matrix4& localToWorld)
{
test.BeginMesh(localToWorld);
SelectionIntersection best;
test.TestTriangles(
vertexpointer_arbitrarymeshvertex(_vertices.data()),
IndexPointer(_indices.data(), IndexPointer::index_type(_indices.size())),
best
);
if(best.valid()) {
selector.addIntersection(best);
}
}
bool ClosestTexturableFinder::pre (const scene::Path& path, scene::Instance& instance) const
{
// Check if the node is filtered
if (path.top().get().visible()) {
// Test the instance for a brush
BrushInstance* brush = Instance_getBrush(instance);
if (brush != NULL) {
// Construct the selectiontest
_selectionTest.BeginMesh(brush->localToWorld());
// Cycle through all the faces
for (Brush::const_iterator i = brush->getBrush().begin(); i != brush->getBrush().end(); i++) {
// Test the face for selection
SelectionIntersection intersection;
(*i)->testSelect(_selectionTest, intersection);
// Any intersection found / is it better than the previous one?
if (intersection.valid() && SelectionIntersection_closer(intersection, _bestIntersection)) {
// Yes, store this as new best intersection
_bestIntersection = intersection;
// Save the face and the parent brush
_texturable.face = (*i);
_texturable.brush = &brush->getBrush();
}
}
} else {
// No brush, test for a patch
SelectionTestable* selectionTestable = Instance_getSelectionTestable(instance);
if (selectionTestable != NULL) {
bool occluded;
OccludeSelector selector(_bestIntersection, occluded);
selectionTestable->testSelect(selector, _selectionTest);
if (occluded) {
_texturable = Texturable();
}
}
}
}
return true;
}
// Perform selection test for this surface
void RenderablePicoSurface::testSelect(Selector& selector,
SelectionTest& test,
const Matrix4& localToWorld) const
{
if (!_vertices.empty() && !_indices.empty())
{
// Test for triangle selection
test.BeginMesh(localToWorld);
SelectionIntersection result;
test.TestTriangles(
VertexPointer(&_vertices[0].vertex, sizeof(ArbitraryMeshVertex)),
IndexPointer(&_indices[0],
IndexPointer::index_type(_indices.size())),
result
);
// Add the intersection to the selector if it is valid
if(result.valid()) {
selector.addIntersection(result);
}
}
}
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);
}
}
void TranslateManipulator::testSelect(const render::View& view, const Matrix4& pivot2world) {
_pivot.update(pivot2world, view.GetModelview(), view.GetProjection(), view.GetViewport());
SelectionPool selector;
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);
{
Matrix4 local2view(view.GetViewMatrix().getMultipliedBy(_pivot._viewpointSpace));
{
SelectionIntersection best;
Quad_BestPoint(local2view, eClipCullCW, &_quadScreen.front(), best);
if(best.valid())
{
best = SelectionIntersection(0, 0);
selector.addSelectable(best, &_selectableScreen);
}
}
}
{
Matrix4 local2view(view.GetViewMatrix().getMultipliedBy(_pivot._worldSpace));
if(show_x)
{
SelectionIntersection best;
Line_BestPoint(local2view, &_arrowX.front(), best);
Triangles_BestPoint(local2view, eClipCullCW, &_arrowHeadX._vertices.front(), &*(_arrowHeadX._vertices.end()-1)+1, best);
selector.addSelectable(best, &_selectableX);
}
if(show_y)
{
SelectionIntersection best;
Line_BestPoint(local2view, &_arrowY.front(), best);
Triangles_BestPoint(local2view, eClipCullCW, &_arrowHeadY._vertices.front(), &*(_arrowHeadY._vertices.end()-1)+1, best);
selector.addSelectable(best, &_selectableY);
}
if(show_z)
{
SelectionIntersection best;
Line_BestPoint(local2view, &_arrowZ.front(), best);
Triangles_BestPoint(local2view, eClipCullCW, &_arrowHeadZ._vertices.front(), &*(_arrowHeadZ._vertices.end()-1)+1, best);
selector.addSelectable(best, &_selectableZ);
}
}
// greebo: If any of the above arrows could be selected, select the first in the SelectionPool
if(!selector.failed()) {
(*selector.begin()).second->setSelected(true);
} else {
Selectable* selectable = NULL;
if (registry::getValue<bool>(RKEY_TRANSLATE_CONSTRAINED)) {
// None of the shown arrows (or quad) has been selected, select an axis based on the precedence
Matrix4 local2view(view.GetViewMatrix().getMultipliedBy(_pivot._worldSpace));
// Get the (relative?) distance from the mouse pointer to the manipulator
Vector3 delta = local2view.t().getProjected();
// Get the precedence (which axis has the absolute largest value in it)
bool xGreaterY = (fabs(delta.x()) > fabs(delta.y()));
// The precedence has to be interpreted according to which axes are visible
if (show_z) {
// Either XZ or YZ
if (show_y) {
// YZ
selectable = (xGreaterY) ? &_selectableY : &_selectableZ;
}
else {
// XZ
selectable = (xGreaterY) ? &_selectableX : &_selectableZ;
}
}
else {
// XY
selectable = (xGreaterY) ? &_selectableX : &_selectableY;
}
}
else {
// Don't constrain to axis, choose the freemove translator
selectable = &_selectableScreen;
}
// If everything went ok, there is a selectable available, add it
if (selectable != NULL) {
selector.addSelectable(SelectionIntersection(0,0), selectable);
selectable->setSelected(true);
}
}
}
