bool CreateBrushTool::handleStartPlaneDrag(InputState& inputState, Planef& plane, Vec3f& initialPoint) {
assert(m_brush == NULL);
Model::EditStateManager& editStateManager = document().editStateManager();
if (inputState.mouseButtons() != MouseButtons::MBLeft ||
inputState.modifierKeys() != ModifierKeys::MKNone ||
editStateManager.selectionMode() != Model::EditStateManager::SMNone)
return false;
Model::FaceHit* hit = static_cast<Model::FaceHit*>(inputState.pickResult().first(Model::HitType::FaceHit, true, m_filter));
if (hit != NULL) {
initialPoint = hit->hitPoint();
} else {
Renderer::Camera& camera = view().camera();
initialPoint = camera.defaultPoint(inputState.pickRay().direction);
}
plane = Planef(Vec3f::PosZ, initialPoint);
m_initialPoint = initialPoint;
updateBounds(m_initialPoint);
Preferences::PreferenceManager& prefs = Preferences::PreferenceManager::preferences();
Renderer::TextureRendererManager& textureRendererManager = document().sharedResources().textureRendererManager();
m_brushFigure = new Renderer::BrushFigure(textureRendererManager);
m_brushFigure->setFaceColor(prefs.getColor(Preferences::FaceColor));
m_brushFigure->setEdgeColor(prefs.getColor(Preferences::SelectedEdgeColor));
m_brushFigure->setOccludedEdgeColor(prefs.getColor(Preferences::OccludedSelectedEdgeColor));
m_brushFigure->setEdgeMode(Renderer::BrushFigure::EMRenderOccluded);
m_brush = new Model::Brush(document().map().worldBounds(), document().map().forceIntegerFacePoints(), m_bounds, document().mruTexture());
m_brushFigure->setBrush(*m_brush);
return true;
}
float Grid::intersectWithRay(const Rayf& ray, unsigned int skip) const {
Vec3f planeAnchor;
for (size_t i = 0; i < 3; i++)
planeAnchor[i] = ray.direction[i] > 0.0f ? snapUp(ray.origin[i], true) + skip * actualSize() : snapDown(ray.origin[i], true) - skip * actualSize();
Planef plane(Vec3f::PosX, planeAnchor);
float distX = plane.intersectWithRay(ray);
plane = Planef(Vec3f::PosY, planeAnchor);
float distY = plane.intersectWithRay(ray);
plane = Planef(Vec3f::PosZ, planeAnchor);
float distZ = plane.intersectWithRay(ray);
float dist = distX;
if (!Math<float>::isnan(distY) && (Math<float>::isnan(dist) || std::abs(distY) < std::abs(dist)))
dist = distY;
if (!Math<float>::isnan(distZ) && (Math<float>::isnan(dist) || std::abs(distZ) < std::abs(dist)))
dist = distZ;
return dist;
}
void CreateBrushTool::handleResetPlane(InputState& inputState, Planef& plane, Vec3f& initialPoint) {
float distance = plane.intersectWithRay(inputState.pickRay());
if (Math<float>::isnan(distance))
return;
initialPoint = inputState.pickRay().pointAtDistance(distance);
if (inputState.modifierKeys() == ModifierKeys::MKAlt) {
Vec3f planeNorm = inputState.pickRay().direction;
planeNorm[2] = 0.0f;
planeNorm.normalize();
plane = Planef(planeNorm, initialPoint);
} else {
plane = Planef::horizontalDragPlane(initialPoint);
}
}
void Frustum::Extract(const Matrix44f &view, const Projection &proj) {
static const int LBN = kLBNCorner, LTN = kLTNCorner, LBF = kLBFCorner,
LTF = kLTFCorner, RBN = kRBNCorner, RTN = kRTNCorner,
RBF = kRBFCorner, RTF = kRTFCorner;
const float lnear = -proj.get_near();
const float lfar = -proj.get_far();
const Vec3f nearNorm(0.0f, 0.0f, -1.0f);
const Vec3f farNorm(0.0f, 0.0f, 1.0f);
// kLeftPlane plane
const Vec3f ltn(proj.get_left(), proj.get_top(), lnear),
lbn(proj.get_left(), proj.get_bottom(), lnear),
ltf(proj.get_far_left(), proj.get_far_top(), lfar),
lbf(proj.get_far_left(), proj.get_far_bottom(), lfar);
const Vec3f leftNorm = vecNormal(
vecCross(lbn - ltn, ltf - ltn));
// kRightPlane plane
const Vec3f rtn(proj.get_right(), proj.get_top(), lnear), // right top near
rbn(proj.get_right(), proj.get_bottom(), lnear), // right bottom near
rtf(proj.get_far_right(), proj.get_far_top(), lfar); // right top far
const Vec3f rightNorm = vecNormal(vecCross(rtf - rtn, rbn - rtn));
// kTopPlane plane
const Vec3f topNorm = vecNormal(vecCross(ltf - ltn, rtn - ltn));
// kBottomPlane plane lbn rbf
const Vec3f rbf(proj.get_far_right(), proj.get_far_bottom(), lfar);
const Vec3f botNorm = vecNormal(vecCross(rbf - rbn, lbn - rbn));
Matrix44f viewSpace, viewSpaceN;
matrixInverse(view, &viewSpace);
viewSpaceN = matrixTranspose(view);
m_conners[LBN] = lbn * viewSpace;
m_conners[LTN] = ltn * viewSpace;
m_conners[LBF] = lbf * viewSpace;
m_conners[LTF] = ltf * viewSpace;
m_conners[RBN] = rbn * viewSpace;
m_conners[RTN] = rtn * viewSpace;
m_conners[RBF] = rbf * viewSpace;
m_conners[RTF] = rtf * viewSpace;
m_planes[kLeftPlane] = Planef(leftNorm * viewSpaceN, m_conners[LTN]);
m_planes[kRightPlane] = Planef(rightNorm * viewSpaceN, m_conners[RTN]);
m_planes[kTopPlane] = Planef(topNorm * viewSpaceN, m_conners[RTN]);
m_planes[kBottomPlane] = Planef(botNorm * viewSpaceN, m_conners[LBN]);
m_planes[kNearPlane] = Planef(nearNorm * viewSpaceN, m_conners[LBN]);
m_planes[kFarPlane] = Planef(farNorm * viewSpaceN, m_conners[RTF]);
}
//------------------------------------------------------------------------------
//!
bool
DFPolygonManipulator::onPointerPress( const Event& ev )
{
_clearSel = false;
// Vertex creation.
if( Core::isKeyPressed( Key::SHIFT ) )
{
// Intersection ray and normal.
float t = CGConstf::infinity();
Rayf ray( camera()->position(), viewport()->direction( ev.position() ) );
Planef plane( Vec3f( 0.0f, 0.0f, 1.0f ) );
if( Intersector::trace( plane, ray, t ) )
{
Vec3f p = ray.point(t);
_editor->createVertex( p );
}
return true;
}
// Picking.
if( _renderable->pick( *viewport(), ev.position(), 10.0f, _pick ) )
{
// Update selection.
if( Core::isKeyPressed(Key::CTRL) )
{
if( !_editor->toggleSelection( _pick ) ) _pick.invalidate();
}
else if( !_editor->selection().has( _pick ) ) _editor->setSelection( _pick );
// Find intersection plane.
Vec3f n( 0.0f, 0.0f, 1.0f );
Vec3f p = editor()->polygon()->vertex( _pick._idx );
_plane = Planef( n, p );
}
else
_clearSel = true;
return !_clearSel;
}
