bool isRaytraced(const MVector3 & origin, const MVector3 & dest, const void * indices, M_TYPES indicesType, const MVector3 * vertices, unsigned int size)
{
M_PROFILE_SCOPE(isRaytraced);
switch(indicesType)
{
case M_USHORT:
{
unsigned int v;
unsigned short * idx = (unsigned short *)indices;
for (v = 0; v < size; v += 3)
{
const MVector3 * v1 = &vertices[idx[v]];
const MVector3 * v2 = &vertices[idx[v+1]];
const MVector3 * v3 = &vertices[idx[v+2]];
// make normal
MVector3 normal = getTriangleNormal(*v1, *v2, *v3);
// if ray intersection return true
if(isEdgeTriangleIntersection(origin, dest, *v1, *v2, *v3, normal, NULL))
return true;
}
}
break;
case M_UINT:
{
unsigned int v;
unsigned int * idx = (unsigned int *)indices;
for (v = 0; v < size; v += 3)
{
const MVector3 * v1 = &vertices[idx[v]];
const MVector3 * v2 = &vertices[idx[v+1]];
const MVector3 * v3 = &vertices[idx[v+2]];
// make normal
MVector3 normal = getTriangleNormal(*v1, *v2, *v3);
// if ray intersection return true
if(isEdgeTriangleIntersection(origin, dest, *v1, *v2, *v3, normal, NULL))
return true;
}
}
break;
default:
break;
}
return false;
}
bool isPointInTriangle(const MVector3 & point, const MVector3 & a, const MVector3 & b, const MVector3 & c, const MVector3 & normal)
{
MVector3 nrm = getTriangleNormal(point, a, b);
if(nrm.dotProduct(normal) < 0)
return false;
nrm = getTriangleNormal(point, b, c);
if(nrm.dotProduct(normal) < 0)
return false;
nrm = getTriangleNormal(point, c, a);
if(nrm.dotProduct(normal) < 0)
return false;
return true;
}
Vec3 Mesh::getFaceNormal(int faceIndex)
{
if (faceIndex < numTriangles)
{
return getTriangleNormal(faceIndex);
}
else
{
return getQuadNormal(faceIndex - numTriangles);
}
}
void getAutoNormals( TriangleMesh& mesh, VectorArray<Vector3>& normalsOut )
{
const uint numVertices = mesh.m_vertices.size();
const uint numTriangles = mesh.m_triangles.size();
normalsOut.clear();
normalsOut.resize( numVertices, Vector3::Zero() );
for ( uint t = 0; t < numTriangles; t++ )
{
const Triangle& tri = mesh.m_triangles[t];
Vector3 n = -getTriangleNormal( mesh, t );
for ( uint i = 0; i < 3; ++i )
{
normalsOut[tri[i]] += n;
}
}
normalsOut.getMap().colwise().normalize();
}
void init_ship(void)
{
Object *o;
nobjects=0;
int ncolors = 0;
char ts[200], *ptr;
int nverts=0;
nfaces = 0;
Vec *vert = new Vec[3000];
iVec *face = new iVec[3000];
Vec *color = new Vec[3000];
FILE *fin = fopen("ship.txt", "r");
if (!fin) printf("file not open\n");
if (fin) {
while(1) {
if (feof(fin)) break;
fgets(ts,100,fin);
ptr = ts;
if (*ptr == 'v') {
ptr = findSpace(ptr)+1;
vert[nverts][0] = atof(ptr);// * 200.0;
ptr = findSpace(ptr)+1;
vert[nverts][1] = atof(ptr);// * 200.0;
ptr = findSpace(ptr)+1;
vert[nverts][2] = atof(ptr);// * 200.0;
nverts++;
continue;
}
if (*ptr == 'f') {
ptr = findSpace(ptr)+1;
face[nfaces][0] = atoi(ptr);
ptr = findSpace(ptr)+1;
face[nfaces][1] = atoi(ptr);
ptr = findSpace(ptr)+1;
face[nfaces][2] = atoi(ptr);
nfaces++;
}
if (*ptr == 'c') {
ptr = findSpace(ptr)+1;
color[ncolors][0] = atof(ptr);
ptr = findSpace(ptr)+1;
color[ncolors][1] = atof(ptr);
ptr = findSpace(ptr)+1;
color[ncolors][2] = atof(ptr);
ncolors++;
}
}
fclose(fin);
}
//Vec mv;
for (int i=0; i<nfaces; i++) {
o = &object[nobjects];
o->type = TYPE_TRIANGLE;
int f;
f=face[i][0]-1; vecMake(vert[f][0],vert[f][1],vert[f][2],o->tri[1]);
f=face[i][1]-1; vecMake(vert[f][0],vert[f][1],vert[f][2],o->tri[0]);
f=face[i][2]-1; vecMake(vert[f][0],vert[f][1],vert[f][2],o->tri[2]);
vecMake(color[i][0],color[i][1],color[i][2], o->color);
//vecMake(0.0, 0.0, 0.0, mv);
for (int j=0; j<3; j++) {
//move(mv, o->tri[j]);
scale(0.45, o->tri[j]);
}
getTriangleNormal(o->tri, o->norm);
//change the color based on normal
//if (o->norm[2] > 0.5 || o->norm[2] < -0.5) {
// vecMake(.1,.1,.1, o->color);
//}
nobjects++;
}
delete vert;
delete face;
delete color;
}
bool getNearestRaytracedPosition(const MVector3 & origin, const MVector3 & dest, const void * indices, M_TYPES indicesType, const MVector3 * vertices, unsigned int size, MVector3 * intersection)
{
M_PROFILE_SCOPE(getNearestRaytracedPosition);
bool isRaytraced = false;
float dist;
float nearDist;
MVector3 I;
MVector3 rayVector = dest - origin;
// init near dist
nearDist = rayVector.getSquaredLength();
switch(indicesType)
{
case M_USHORT:
{
unsigned int v;
unsigned short * idx = (unsigned short *)indices;
for (v = 0; v < size; v += 3)
{
const MVector3 * v1 = &vertices[idx[v]];
const MVector3 * v2 = &vertices[idx[v+1]];
const MVector3 * v3 = &vertices[idx[v+2]];
// make normal
MVector3 normal = getTriangleNormal(*v1, *v2, *v3);
// compute ray intersection
if(isEdgeTriangleIntersection(origin, dest, *v1, *v2, *v3, normal, &I))
{
rayVector = I - origin;
dist = rayVector.getSquaredLength();
if(dist < nearDist)
{
nearDist = dist;
(*intersection) = I;
}
isRaytraced = true;
}
}
}
break;
case M_UINT:
{
unsigned int v;
unsigned int * idx = (unsigned int *)indices;
for (v = 0; v < size; v += 3)
{
const MVector3 * v1 = &vertices[idx[v]];
const MVector3 * v2 = &vertices[idx[v+1]];
const MVector3 * v3 = &vertices[idx[v+2]];
// make normal
MVector3 normal = getTriangleNormal(*v1, *v2, *v3);
// compute ray intersection
if(isEdgeTriangleIntersection(origin, dest, *v1, *v2, *v3, normal, &I))
{
rayVector = I - origin;
dist = rayVector.getSquaredLength();
if(dist < nearDist)
{
nearDist = dist;
(*intersection) = I;
}
isRaytraced = true;
}
}
}
break;
default:
break;
}
return isRaytraced;
}
