bool AmbientOcclusionEngine::rayIntersectsTriangle(Vec const& origin, Vec const& ray,
unsigned const triangle)
{
Vec a(vertex(3*triangle+0));
Vec b(vertex(3*triangle+1));
Vec c(vertex(3*triangle+2));
Vec ab(b-a);
Vec ac(c-a);
Vec pvec(ray^ac);
double det(ab*pvec);
if (std::abs(det) < Epsilon) return false;
double invDet(1.0/det);
Vec tvec(origin-a);
double u(tvec*pvec);
u *= invDet;
if (u < 0.0 || u > 1.0) return false;
Vec qvec(tvec^ab);
double v(invDet*(ray*qvec));
if (v < 0.0 || u + v > 1.0) return false;
double t(ac*qvec);
return t > Epsilon;
}
Intersection Triangle::intersect(const Ray &r) const
{
const Vec3t edge1(V1-V0), edge2(V2-V0); // could precalculate
Vec3t pvec(cross(r.getNormal(), edge2));
DefType det=dot(edge1,pvec);
if (det < MM_EPSILON)
return Intersection();
Vec3t tvec(r.getPoint()-V0);
DefType u=dot(tvec,pvec);
if (u < 0 || u > det)
return Intersection();
Vec3t qvec(cross(tvec,edge1));
DefType v=dot(r.getPoint(),qvec);
if (v < 0 || u+v > det)
return Intersection();
DefType t=dot(edge2, qvec)/det;
return Intersection(r.positionAtTime(t), m_normal, t, true, true);
}
CVector3 CQuaternion::operator* (const CVector3& v) const {
#if 0
CMatrix4 m;
toRotationMatrix(m);
return m * v;
#else
// nVidia SDK implementation
CVector3 uv, uuv;
CVector3 qvec(x, y, z);
uv = qvec ^ v;
uuv = qvec ^ uv;
uv *= (2.0f * w);
uuv *= 2.0f;
return v + uv + uuv;
#endif
#if 0
CQuaternion thiss = *this;
thiss.invert();
thiss = thiss * CQuaternion(v.x, v.y, v.z, 0.0);
thiss = thiss * *this;
return CVector3(thiss.x, thiss.y, thiss.z);
#endif
}
Vector3 Quaternion::operator* (Vector3 v)
{
Vector3 uv, uuv;
Vector3 qvec(x, y, z);
uv = qvec.crossProduct(v);
uuv = qvec.crossProduct(uv);
uv *= (2.0f * w);
uuv *= 2.0f;
return v + uv + uuv;
}
Vector3 Quaternion::operator* (const Vector3& v) const
{
// nVidia SDK implementation
Vector3 uv, uuv;
Vector3 qvec(_v[0], _v[1], _v[2]);
uv = qvec ^ v;
uuv = qvec ^ uv;
uv *= ( 2.0f * _v[3] );
uuv *= 2.0f;
return v + uv + uuv;
}
Vector3 Quaternion::operator*( const Vector3& v ) const
{
// nVidia SDK implementation
Vector3 qvec( x, y, z );
Vector3 uv = cross( qvec, v );
Vector3 uuv = cross( qvec, uv );
uv *= ( 2.0 * w );
uuv *= 2.0;
return v + uv + uuv;
}
HawkVector3D HawkQuaternion::operator * (const HawkVector3D& oVec3) const
{
HawkVector3D uv, uuv;
HawkVector3D qvec(X, Y, Z);
uv = qvec.CrossProduct(oVec3);
uuv = qvec.CrossProduct(uv);
uv *= (2.0f * W);
uuv *= 2.0f;
return oVec3 + uv + uuv;
}
// Vector3 Transform
static Vector3 GetVectorTransform(const Quaternion& quat, const Vector3& vec)
{
Vector3 qvec(quat.x, quat.y, quat.z);
Vector3 v1 = qvec.CrossProduct(vec);
Vector3 v2 = qvec.CrossProduct(v1);
v1 *= (2 * quat.w);
v2 *= 2;
return vec + v1 + v2;//Vector3(quat.x * vec.x, quat.y * vec.y, quat.z * vec.z);
}
Vector3f operator*(const Vector3f& v) const {
// nVidia SDK implementation
Vector3f uv, uuv;
Vector3f qvec(x_, y_, z_);
uv = qvec.cross(v);
uuv = qvec.cross(uv);
uv *= (2.0f * w_);
uuv *= 2.0f;
return v + uv + uuv;
}
PHVector3 PHQuaternion::operator* (const PHVector3 & v) const
{
PHVector3 uv, uuv;
PHVector3 qvec(x, y, z);
uv = qvec.cross(v);
uuv = qvec.cross(uv);
uv *= (2.0f * w);
uuv *= 2.0f;
return v + uv + uuv;
}
Vector3 operator*(const Quaternion &lhs, const Vector3 &rhs)
{
// nVidia SDK implementation
Vector3 uv, uuv;
Vector3 qvec(lhs.x, lhs.y, lhs.z);
uv = Vector3::CrossProduct(qvec, rhs);
uuv = Vector3::CrossProduct(qvec, uv);
uv *= (2.0f * lhs.w);
uuv *= 2.0f;
return rhs + uv + uuv;
}
Vector3 Quaternion::operator* (const Vector3& v) const
{
// nVidia SDK implementation
Vector3 uv, uuv;
Vector3 qvec(x, y, z);
uv = qvec.crossProduct(v);
uuv = qvec.crossProduct(uv);
uv *= (2.0f * w);
uuv *= 2.0f;
return v + uv + uuv;
}
Vec3 Quat::operator* (const Vec3& v) const
{
// from nVidia SDK
Vec3 uv, uuv;
Vec3 qvec(x, y, z);
uv = qvec.Cross(v);
uuv = qvec.Cross(uv);
uv *= (2.0f * w);
uuv *= 2.0f;
return v + uv + uuv;
}
CVector3D CQuaternion::operator* (const CVector3D& vec) const
{
CVector3D uv, uuv;
CVector3D qvec(m_X, m_Y, m_Z);
uv = qvec.Cross(vec);
uuv = qvec.Cross(uv);
uv *= (2.0f * m_W);
uuv *= 2.0f;
return vec + uv + uuv;
}
Vector3f Quaternion::operator* (const Vector3f& v) const
{
// nVidia SDK implementation
Vector3f uv, uuv;
Vector3f qvec(q2, q3, q4);
uv = qvec.cross(v);
uuv = qvec.cross(uv);
uv *= (2.0f * q1);
uuv *= 2.0f;
return v + uv + uuv;
}
Vec3 Quat::operator*( const Vec3& v ) const
{
// nVidia SDK implementation
Vec3 uv, uuv;
Vec3 qvec( X(), Y(), Z() );
uv = qvec.GetCrossProduct( v );
uuv = qvec.GetCrossProduct( uv );
uv *= ( 2.0f * W() );
uuv *= 2.0f;
return v + uv + uuv;
}
//-----------------------------------------------------------------
NMVector3 operator * (const NMQuaternion &q, const NMVector3 &v)
{
// Nvidia SDK implementation
NMVector3 uv, uuv;
NMVector3 qvec(q.x, q.y, q.z);
uv = NMVector3::Cross(qvec, v);
uuv = NMVector3::Cross(qvec, uv);
uv *= (2.0f * q.w);
uuv *= 2.0f;
return v + uv + uuv;
}
void CollisionFace::RayTrace(const VC3 &position, const VC3 &direction, float ray_length, Storm3D_CollisionInfo &rti, bool accurate)
{
// Begin calculating determinant - also used to calculate U parameter
VC3 pvec(direction.y * e02.z - direction.z * e02.y, direction.z * e02.x - direction.x * e02.z, direction.x * e02.y - direction.y * e02.x);
// If determinant is near zero, ray lies in plane of triangle
float det = e01.x * pvec.x + e01.y*pvec.y + e01.z * pvec.z;
if(det < 0.0001f)
return;
// Calculate distance from vert0 to ray origin
VC3 tvec(position.x - vertex0.x, position.y - vertex0.y, position.z - vertex0.z);
// Calculate U parameter and test bounds
float u = tvec.x * pvec.x + tvec.y * pvec.y + tvec.z * pvec.z;
if((u < 0) || (u > det))
return;
// Prepare to test V parameter
VC3 qvec(tvec.y * e01.z - tvec.z * e01.y, tvec.z * e01.x - tvec.x * e01.z, tvec.x * e01.y - tvec.y * e01.x);
// Calculate V parameter and test bounds
float v = direction.x * qvec.x + direction.y * qvec.y + direction.z * qvec.z;
if((v < 0) || ((u + v) > det))
return;
// Calculate t, scale parameters, ray intersects triangle
float t = e02.x * qvec.x + e02.y * qvec.y + e02.z * qvec.z;
t /= det;
// Set collision info
if((t < rti.range) && (t < ray_length) && (t > 0))
{
rti.hit = true;
rti.range = t;
rti.position = position+direction*t;
rti.plane_normal = plane.planenormal;
}
}
