__host__ __device__ void shade(const Ray& ray, KernelArray<Light> lights, KernelArray<Renderable> objects, uchar4* bgnd, uchar4* out) const
{
// An object shader doesn't really do too much other than
// supply a few critical bits of geometric information
// for a surface shader. It must must compute:
//
// 1. the point of intersection (p)
// 2. a unit-length surface normal (n)
// 3. a unit-length vector towards the ray's origin (v)
//
Vector3Df p = ray.getOrigin() + ray.getT() * ray.getDirection();
Vector3Df v = -ray.getDirection();
Vector3Df n;
switch(type)
{
case SPHERE:
{
const Vector3Df& center = parameter.data[0];
n = p - center;
}
break;
case PLANE:
{
const Vector3Df& planeNormal = parameter.data[0];
n = planeNormal;
}
break;
}
n.normalize();
surface.shade<depth>(p, n, v, lights, objects, bgnd, out);
}
//////////////////////////////////////////////////////////////////////////
// Advanced Shader Methods
//////////////////////////////////////////////////////////////////////////
void SetTangentSpaceMatrix(TangentSpaceVertex& p0, const TangentSpaceVertex& p1, const TangentSpaceVertex& p2, bool setNormals_)
{
Vector3Df v1(p1.x_ - p0.x_, p1.y_ - p0.y_, p1.z_ - p0.z_);
Vector3Df v2(p2.x_ - p0.x_, p2.y_ - p0.y_, p2.z_ - p0.z_);
Vector2Df t1(p1.u_ - p0.u_, p1.v_ - p0.v_);
Vector2Df t2(p2.u_ - p0.u_, p2.v_ - p0.v_);
const float DET = 1.0f / (t1.x * t2.y - t2.x * t1.y);
Vector3Df tangent = (v1 * t2.y - v2 * t1.y) * DET;
Vector3Df biTangent = (v1 * -t2.x + v2 * t1.x) * DET;
tangent.Normalize();
biTangent.Normalize();
p0.tstx_ = tangent.x;
p0.tsty_ = tangent.y;
p0.tstz_ = tangent.z;
p0.tsbx_ = biTangent.x;
p0.tsby_ = biTangent.y;
p0.tsbz_ = biTangent.z;
if(setNormals_)
{
p0.nx_ = biTangent.y * tangent.z - biTangent.z * tangent.y;
p0.ny_ = biTangent.z * tangent.x - biTangent.x * tangent.z;
p0.nz_ = biTangent.x * tangent.y - biTangent.y * tangent.x;
}
}
Color::Color( const Vector3Df &clColor )
: m_u32Color( 0 )
{
SetHex( RGBAToHex( static_cast<Unsigned8>( clColor.GetX() * MAX_U8 ),
static_cast<Unsigned8>( clColor.GetY() * MAX_U8 ),
static_cast<Unsigned8>( clColor.GetZ() * MAX_U8 ),
MAX_U8 ) );
}
void fix_normals(void)
{
for (unsigned j = 0; j<g_trianglesNo; j++) {
Vector3Df worldPointA = g_vertices[g_triangles[j]._idx1];
Vector3Df worldPointB = g_vertices[g_triangles[j]._idx2];
Vector3Df worldPointC = g_vertices[g_triangles[j]._idx3];
Vector3Df AB = worldPointB;
AB -= worldPointA;
Vector3Df AC = worldPointC;
AC -= worldPointA;
Vector3Df cr = cross(AB, AC);
cr.normalize();
g_triangles[j]._normal = cr;
g_vertices[g_triangles[j]._idx1]._normal += cr;
g_vertices[g_triangles[j]._idx2]._normal += cr;
g_vertices[g_triangles[j]._idx3]._normal += cr;
}
for (unsigned j = 0; j<g_trianglesNo; j++) {
g_vertices[g_triangles[j]._idx1]._normal.normalize();
g_vertices[g_triangles[j]._idx2]._normal.normalize();
g_vertices[g_triangles[j]._idx3]._normal.normalize();
}
}
void InteractiveCamera::strafe(float m){
Vector3Df strafeAxis = cross(viewDirection, Vector3Df(0, 1, 0));
strafeAxis.normalize();
centerPosition += strafeAxis * m;
}
