void BaseView::tumble(int dx, int dy, int portWidth)
{
Vector3F side = m_space.getSide();
Vector3F up = m_space.getUp();
Vector3F front = m_space.getFront();
Vector3F eye = m_space.getTranslation();
Vector3F toEye = eye - m_centerOfInterest;
float dist = toEye.length();
const float scaleing = dist * 2.f / (float)portWidth;
eye -= side * (float)dx * scaleing;
eye += up * (float)dy * scaleing;
toEye = eye - m_centerOfInterest;
toEye.normalize();
eye = m_centerOfInterest + toEye * dist;
m_space.setTranslation(eye);
front = toEye;
side = up.cross(front);
side.y = 0.f;
side.normalize();
up = front.cross(side);
up.normalize();
m_space.setOrientations(side, up, front);
m_invSpace = m_space;
m_invSpace.inverse();
}
void GeometryCorrectionTable::apply_z_correction(
const Vector3F& edge_dir, MatrixFr& loop) {
//const Float max_z_error = 0.125;
//const Float max_z_error = 0.09;
const Float max_z_error = 0.00;
VectorF bbox_min = loop.colwise().minCoeff();
VectorF bbox_max = loop.colwise().maxCoeff();
VectorF bbox_center = 0.5 * (bbox_min + bbox_max);
Vector3F side_dir = edge_dir.cross(Vector3F::UnitZ());
Float sin_val = side_dir.norm();
if (sin_val < 1e-3) return;
const size_t num_vts = loop.rows();
for (size_t i=0; i<num_vts; i++) {
Vector3F v = loop.row(i) - bbox_center.transpose();
Float side_component = side_dir.dot(v) / sin_val;
Vector3F proj_v = v - side_component * side_dir / sin_val;
Float proj_component = proj_v.norm();
if (proj_component > 1e-3) {
proj_v -= proj_v / proj_component * (sin_val * max_z_error);
}
loop.row(i) = bbox_center + proj_v + side_component * side_dir / sin_val;
}
}
void TransformManipulator::spin(const Vector3F & d)
{
Matrix44F ps;
parentSpace(ps);
Matrix44F invps = ps;
invps.inverse();
const Vector3F worldP = ps.transform(translation());
const Vector3F rotUp = ps.transformAsNormal(hitPlaneNormal());
Vector3F toa = m_currentPoint - worldP;
Vector3F tob = toa + d;
toa.normalize();
tob.normalize();
float ang = toa.angleBetween(tob, toa.cross(rotUp).reversed());
Vector3F angles;
if(m_rotateAxis == AY) angles.set(0.f, ang, 0.f);
else if(m_rotateAxis == AZ) angles.set(0.f, 0.f, ang);
else angles.set(ang, 0.f, 0.f);
m_subject->rotate(angles);
setRotationAngles(m_subject->rotationAngles());
}
Matrix33F Patch::tangentFrame() const
{
Matrix33F frm;
Vector3F du = (vertex(1) - vertex(0) + vertex(2) - vertex(3)) * .5f;
Vector3F dv = (vertex(3) - vertex(0) + vertex(2) - vertex(1)) * .5f;
du.normalize();
dv.normalize();
Vector3F side = du.cross(dv);
side.normalize();
Vector3F up = du.cross(side);
up.normalize();
frm.fill(side, up, du);
return frm;
}
Vector3F NormalsUtils::calculateNormal(const IFloatBuffer* vertices,
short index0,
short index1,
short index2) {
const Vector3F vertex0 = getVertex(vertices, index0);
const Vector3F vertex1 = getVertex(vertices, index1);
const Vector3F vertex2 = getVertex(vertices, index2);
const Vector3F p10 = vertex1.sub(vertex0);
const Vector3F p20 = vertex2.sub(vertex0);
return p10.cross(p20);
}
char BaseMesh::triangleIntersect(const Vector3F * threeCorners, IntersectionContext * ctx) const
{
Vector3F a = threeCorners[0];
Vector3F b = threeCorners[1];
Vector3F c = threeCorners[2];
Vector3F ab = b - a;
Vector3F ac = c - a;
Vector3F nor = ab.cross(ac);
nor.normalize();
Ray &ray = ctx->m_ray;
float ddotn = ray.m_dir.dot(nor);
if(!ctx->twoSided && ddotn > 0.f) return 0;
float t = (a.dot(nor) - ray.m_origin.dot(nor)) / ddotn;
if(t < 0.f || t > ray.m_tmax) return 0;
//printf("face %i %f %f", idx, t, ctx->m_minHitDistance);
if(t > ctx->m_minHitDistance) return 0;
Vector3F onplane = ray.m_origin + ray.m_dir * t;
Vector3F e01 = b - a;
Vector3F x0 = onplane - a;
if(e01.cross(x0).dot(nor) < 0.f) return 0;
//printf("pass a\n");
Vector3F e12 = c - b;
Vector3F x1 = onplane - b;
if(e12.cross(x1).dot(nor) < 0.f) return 0;
//printf("pass b\n");
Vector3F e20 = a - c;
Vector3F x2 = onplane - c;
if(e20.cross(x2).dot(nor) < 0.f) return 0;
//printf("pass c\n");
ctx->m_hitP = onplane;
ctx->m_hitN = nor;
ctx->m_minHitDistance = t;
ctx->m_geometry = (Geometry*)this;
ctx->m_success = 1;
return 1;
}
void InverseBilinearInterpolate::setVertices(const Vector3F & a, const Vector3F & b, const Vector3F & c, const Vector3F & d)
{
Vector3F side = b - a; side.normalize();
Vector3F up = c - a;
Vector3F front = side.cross(up); front.normalize();
up = front.cross(side); up.normalize();
m_space.setIdentity();
m_space.setTranslation(a);
m_space.setOrientations(side, up, front);
m_space.inverse();
Vector3F A = m_space.transform(a);
Vector3F B = m_space.transform(b);
m_E.set(B.x, B.y);
Vector3F C = m_space.transform(c);
m_F.set(C.x, C.y);
Vector3F D = m_space.transform(d);
m_G.set(-B.x - C.x + D.x, -B.y - C.y + D.y);
}
void Vector3F::rotateAroundAxis(const Vector3F& axis, float theta)
{
if(theta==0) return;
Vector3F ori(x,y,z);
float l = ori.length();
ori.normalize();
Vector3F up = axis.cross(ori);
up.normalize();
Vector3F side = ori - axis*(axis.dot(ori));
up *=side.length();
ori += side*(cos(theta) - 1);
ori += up*sin(theta);
ori.normalize();
x = ori.x*l;
y = ori.y*l;
z = ori.z*l;
}
float FEMTetrahedronMesh::getTetraVolume(Vector3F e1, Vector3F e2, Vector3F e3) {
return e1.dot( e2.cross( e3 ) )/ 6.0f;
}
void Matrix44F::setFrontOrientation(const Vector3F& front)
{
Vector3F side = front.perpendicular();
Vector3F up = front.cross(side);
setOrientations(side, up, front);
}