VOID
SwapSplayLinks (
IN PRTL_SPLAY_LINKS Link1,
IN PRTL_SPLAY_LINKS Link2
)
{
PRTL_SPLAY_LINKS *Parent1ChildPtr;
PRTL_SPLAY_LINKS *Parent2ChildPtr;
/*
We have the following situation
Parent1 Parent2
| |
| |
Link1 Link2
/ \ / \
/ \ / \
LC1 RC1 LC2 RC2
where one of the links can possibly be the root and one of the links
can possibly be a direct child of the other. Without loss of
generality we'll make link2 be the possible and root and link1 be
the possible child.
*/
if ((RtlIsRoot(Link1)) || (RtlParent(Link2) == Link1)) {
SwapPointers(Link1, Link2);
}
//
// The four cases we need to handle are
//
// 1. Link1 is not a child of link2 and link2 is not the root
// 2. Link1 is not a child of link2 and link2 is the root
// 3. Link1 is a child of link2 and link2 is not the root
// 4. Link1 is a child of link2 and link2 is the root
//
//
// Each case will be handled separately
//
if (RtlParent(Link1) != Link2) {
if (!RtlIsRoot(Link2)) {
//
// Case 1 the initial steps are:
//
// 1. get both parent child pointers
// 2. swap the parent child pointers
// 3. swap the parent pointers
//
Parent1ChildPtr = ParentsChildPointerAddress(Link1);
Parent2ChildPtr = ParentsChildPointerAddress(Link2);
SwapPointers(*Parent1ChildPtr, *Parent2ChildPtr);
SwapPointers(Link1->Parent, Link2->Parent);
} else {
//
// Case 2 the initial steps are:
//
// 1. Set link1's parent child pointer to link2
// 2. Set parent pointer of link2 to link1's parent
// 3. Set parent pointer of link1 to be itself
//
Parent1ChildPtr = ParentsChildPointerAddress(Link1);
*Parent1ChildPtr = Link2;
Link2->Parent = Link1->Parent;
Link1->Parent = Link1;
}
//
// Case 1 and 2 common steps are:
//
// 1. swap the child pointers
//
SwapPointers(Link1->LeftChild, Link2->LeftChild);
SwapPointers(Link1->RightChild, Link2->RightChild);
} else { // RtlParent(Link1) == Link2
if (!RtlIsRoot(Link2)) {
//
// Case 3 the initial steps are:
//
// 1. Set Link2's parent child pointer to link1
// 2. Set Link1's parent pointer to parent of link2
//
Parent2ChildPtr = ParentsChildPointerAddress(Link2);
*Parent2ChildPtr = Link1;
Link1->Parent = Link2->Parent;
} else {
//
// Case 4 the initial steps are:
//
// 1. Set Link1's parent pointer to be link1
//
Link1->Parent = Link1;
}
//
// Case 3 and 4 common steps are:
//
// 1. Swap the child pointers
// 2. if link1 was a left child (i.e., RtlLeftChild(Link1) == Link1)
// then set left child of link1 to link2
// else set right child of link1 to link2
//
SwapPointers(Link1->LeftChild, Link2->LeftChild);
SwapPointers(Link1->RightChild, Link2->RightChild);
if (Link1->LeftChild == Link1) {
Link1->LeftChild = Link2;
} else {
Link1->RightChild = Link2;
}
}
//
// Case 1, 2, 3, 4 common (and final) steps are:
//
// 1. Fix the parent pointers of the left and right children
//
if (Link1->LeftChild != NULL) {Link1->LeftChild->Parent = Link1;}
if (Link1->RightChild != NULL) {Link1->RightChild->Parent = Link1;}
if (Link2->LeftChild != NULL) {Link2->LeftChild->Parent = Link2;}
if (Link2->RightChild != NULL) {Link2->RightChild->Parent = Link2;}
}
/*
* "propagation" makes the forward of the acoustic wave
* vm: velocity model data
* Xi, Yi, Zi: velocity model dimensions n3, n2, n1
* dx, dy, dz: spatial resolution
* tr: source/seismic traces data
* Ti: number of samples per data source/seismic trace
* dt: temporal resolution
* trc: coordinates of source/seismic traces
* Ntr: number of source/seismic traces
* wri: write the current wavefield in a binary file at each wri timesteps. wri=0 means do not write
* wffn: wavefield record file name
* bw: border width
*/
void propagation(float *vel, unsigned int localXi, unsigned int localYi, int Yi, int Zi, float dx, float dy, float dz, float *tr, unsigned short Ti, float dt, int *trc, int Ntr, int wri, char *wffn, int bw, int my_rank, unsigned int shotNumber, unsigned int iMax) {
int xbi, ybi, zbi, ti, c, ntr; // auxiliary variables
unsigned long localXbi, localYbi, Ybi, Zbi, indb, ivb;
float fdx, fdy, fdz; // auxiliary variables
u_t u; // wavefield
char fileName [40];
FILE *wff2; // Wavefield record file
//float cx[ncx] = {-2.847222222, 1.6, -0.2, 0.025396825, -0.001785714}; // coefficients of the finite difference in x
//float cy[ncy] = {-2.847222222, 1.6, -0.2, 0.025396825, -0.001785714}; // coefficients of the finite difference in y
//float cz[ncz] = {-2.847222222, 1.6, -0.2, 0.025396825, -0.001785714}; // coefficients of the finite difference in z
float cx[ncx] = {-205.0/72.0, 1.6, -0.2, 8.0/315.0, -1.0/560.0}; // coefficients of the finite difference in x
float cy[ncy] = {-205.0/72.0, 1.6, -0.2, 8.0/315.0, -1.0/560.0}; // coefficients of the finite difference in y
float cz[ncz] = {-205.0/72.0, 1.6, -0.2, 8.0/315.0, -1.0/560.0}; // coefficients of the finite difference in z
FILE *wff = fopen(wffn,"wb"); // Wafield record file
// Check the opening file
if (!wff) {
printf("Failed opening file.\n");
return;
}
// Auxiliary variables initialization
localXbi = localXi + 2*bw;
localYbi = localYi + 2*bw;
Ybi = Yi + 2*bw;
Zbi = Zi + 2*bw;
// Memory allocation
u.pn = (float *) calloc(localXbi*localYbi*Zbi,sizeof(float));
if (u.pn == NULL) {
printf("Memory allocation failed: u.pn.\n");
return;
}
u.cur = (float *) calloc(localXbi*localYbi*Zbi,sizeof(float));
if (u.cur == NULL) {
printf("Memory allocation failed: u.cur.\n");
return;
}
printf("u Size: %lu\n", localXbi*localYbi*Zbi);
printf("Rank: %d\tComputando tiro = %u\n", my_rank, shotNumber);
printf("Ti = %d\n", Ti);
fflush(stdout);
//float velMax2 = 0;
// Propagation
for (ti = 0; ti < Ti; ti++) {
for (xbi = ncx-1; xbi < localXbi-ncx+1; xbi++) {
for (ybi = ncy-1; ybi < localYbi-ncy+1; ybi++) {
for (zbi = ncz-1; zbi < Zbi-ncz+1; zbi++) {
indb = xbi*localYbi*Zbi + ybi*Zbi + zbi;
fdx = cx[0]*u.cur[indb];
fdy = cy[0]*u.cur[indb];
fdz = cz[0]*u.cur[indb];
for (c = 1; c < ncx; c++) {
fdx += cx[c]*(u.cur[indb + c*localYbi*Zbi] + u.cur[indb - c*localYbi*Zbi]);
}
for (c = 1; c < ncy; c++) {
fdy += cy[c]*(u.cur[indb + c*Zbi] + u.cur[indb - c*Zbi]);
}
for (c = 1; c < ncz; c++) {
fdz += cz[c]*(u.cur[indb + c] + u.cur[indb - c]);
}
fdx *= 1/(dx*dx);
fdy *= 1/(dy*dy);
fdz *= 1/(dz*dz);
ivb = xbi*Ybi*Zbi + ybi*Zbi + zbi;
/*if(ti == 0 && velMax2 < vel[ivb])
{
velMax2 = vel[ivb];
iMax = ivb;
}*/
u.pn[indb] = 2*u.cur[indb] - u.pn[indb] + vel[ivb]*(fdx + fdy + fdz);
//if(u.pn[indb] != 0 && ti < 3)
//{
// printf("Ti: %d\tu.pn[%lu] = %.3f\n", ti, indb, u.pn[indb]);
//}
if(zbi == bw && xbi == 57 && ybi == 63)
{
u.pn[indb] = 100;
}
//if(indb == (trc[0]+bw)*localYbi*Zbi + (trc[1]+bw)*Zbi + trc[2]+bw)
/*if(indb == iMax)
{
//printf("fdx: %.3f\tfdy: %.3f\tfdz: %.3f\tvel[%lu] = %.3f\n", fdx, fdy, fdz, ivb, vel[ivb]);
}*/
}
}
}
//printf("Rank: %d\tTi: %d\tti = %d\n", my_rank, Ti, ti);
// Source/seismic traces
// Corrigir trc, ivb
// Verificar indices
/*for (ntr = 0; ntr < Ntr; ntr++) {
indb = (trc[ntr*3]+bw)*localYbi*Zbi + (trc[ntr*3+1]+bw)*Zbi + trc[ntr*3+2]+bw;
ivb = (trc[ntr*3]+bw)*Ybi*Zbi + (trc[ntr*3+1]+bw)*Zbi + (trc[ntr*3+2]+bw);
//printf("Antes Sub Rank: %d\tTi = %d\tti = %d\tu.pn[%lu] = %.3f\n", my_rank, Ti, ti, indb, u.pn[indb]);
u.pn[indb] -= vel[ivb]*tr[ntr*Ti + ti];
printf("Rank: %d\tTi = %d\tti = %d\tu.pn[%lu] = %.3f\n", my_rank, Ti, ti, indb, u.pn[indb]);
}*/
//printf("Rank: %d\tti = %d\tu.pn[%lu] = %.3f\n", my_rank, ti, indb, u.pn[indb]);
SwapPointers(&u.pn, &u.cur);
// Write wavefield in a file
if (wri != 0) {
if ((ti+1)%wri == 0) {
sprintf(fileName, "./pDireta/direta_%d_%d.bin", shotNumber,ti);
wff2 = fopen(fileName,"wb");
for (xbi = bw; xbi < localXbi-bw; xbi++) {
for (ybi = bw; ybi < localYbi-bw; ybi++) {
//printf("u atual: %.3f\n", u.cur[xbi*localYbi*Zbi + ybi*Zbi + bw]);
if (fwrite(&u.cur[xbi*localYbi*Zbi + ybi*Zbi + bw], sizeof(float), Zi, wff2) != Zi) {
printf("Failed writing wavefield file\n");
return;
}
}
}
fclose(wff2);
}
}
}
// Free memory
free(u.pn);
free(u.cur);
fclose(wff);
}
VOID
TriSwapSplayLinks (
IN PTRI_SPLAY_LINKS Link1,
IN PTRI_SPLAY_LINKS Link2
)
{
PULONG Parent1ChildRef;
PULONG Parent2ChildRef;
PULONG Child1ParSibRef;
PULONG Child2ParSibRef;
//
// We have the following situation
//
//
// Parent1 Parent2
// | |
// | |
// Link1 Link2
// / \ / \
// / \ / \
// LC1 RC1 LC2 RC2
//
// where one of the links can possibly be the root and one of the links
// can possibly be a direct child of the other, or can be connected
// via their sibling pointers. Without loss of generality we'll make
// link2 be the possible and root and link1 be the possible child, or
// link2 have a parsib pointer to link1
//
if ((TriIsRoot(Link1)) ||
(TriParent(Link2) == Link1) ||
(MakeIntoPointer(Link1->Refs.ParSib) == Link2)) {
SwapPointers(Link1, Link2);
}
//
// The cases we need to handle are
//
// 1. Link1 is not a child of link2, link2 is not the root, and they are not siblings
// 2. Link1 is not a child of link2, link2 is not the root, and they are siblings
//
// 3. Link1 is not a child of link2, link2 is the root
//
// 4. Link1 is an only child of link2, and link2 is not the root
// 5. Link1 is an only child of link2, and link2 is the root
//
// 6. Link1 is a left child of link2 (has a sibling), and link2 is not the root
// 7. Link1 is a left child of link2 (has a sibling), and link2 is the root
//
// 8. Link1 is a right child of link2 (has a sibling), and link2 is not the root
// 9. Link1 is a right child of link2 (has a sibling), and link2 is the root
//
// Each case will be handled separately
//
if (TriParent(Link1) != Link2) {
if (!TriIsRoot(Link2)) {
if (MakeIntoPointer(Link2->Refs.ParSib) != Link1) {
//
// Case 1 - Link1 is not a child of link2,
// Link2 is not the root, and
// they are not siblings
//
Parent1ChildRef = TriAddressOfBackRefViaParent(Link1);
Child1ParSibRef = TriAddressOfBackRefViaChild(Link1);
Parent2ChildRef = TriAddressOfBackRefViaParent(Link2);
Child2ParSibRef = TriAddressOfBackRefViaChild(Link2);
SwapUlongs(Link1->Refs.Child, Link2->Refs.Child);
SwapUlongs(Link1->Refs.ParSib, Link2->Refs.ParSib);
SetRefViaPointer(Parent1ChildRef, Link2);
SetRefViaPointer(Parent2ChildRef, Link1);
SetRefViaPointer(Child1ParSibRef, Link2);
SetRefViaPointer(Child2ParSibRef, Link1);
} else {
//
// Case 2 - Link1 is not a child of link2,
// Link2 is not the root, and
// they are siblings
//
Child1ParSibRef = TriAddressOfBackRefViaChild(Link1);
Parent2ChildRef = TriAddressOfBackRefViaParent(Link2);
Child2ParSibRef = TriAddressOfBackRefViaChild(Link2);
SwapUlongs(Link1->Refs.Child, Link2->Refs.Child);
SetRefViaPointer(Child1ParSibRef, Link2);
SetRefViaPointer(Child2ParSibRef, Link1);
*Parent2ChildRef = MakeIntoLeftChildRef(Link1);
Link2->Refs.ParSib = Link1->Refs.ParSib;
Link1->Refs.ParSib = MakeIntoSiblingRef(Link2);
}
} else {
//
// Case 3 - Link1 is not a child of link2, and
// Link2 is the root
//
Parent1ChildRef = TriAddressOfBackRefViaParent(Link1);
Child1ParSibRef = TriAddressOfBackRefViaChild(Link1);
Child2ParSibRef = TriAddressOfBackRefViaChild(Link2);
SwapUlongs(Link1->Refs.Child, Link2->Refs.Child);
Link2->Refs.ParSib = Link1->Refs.ParSib;
Link1->Refs.ParSib = MakeIntoParentRef(Link1);
SetRefViaPointer(Child1ParSibRef, Link2);
SetRefViaPointer(Child2ParSibRef, Link1);
SetRefViaPointer(Parent1ChildRef, Link2);
}
} else { // TriParent(Link1) == Link2
if (MakeIntoPointer(Link2->Refs.Child) == Link1 &&
MakeIntoPointer(Link1->Refs.ParSib) == Link2) { // Link1 is an only child
if (!TriIsRoot(Link2)) {
//
// Case 4 - Link1 is an only child of link2, and
// Link2 is not the root
//
Child1ParSibRef = TriAddressOfBackRefViaChild(Link1);
Parent2ChildRef = TriAddressOfBackRefViaParent(Link2);
SetRefViaPointer(Child1ParSibRef, Link2);
SetRefViaPointer(Parent2ChildRef, Link1);
Link1->Refs.ParSib = Link2->Refs.ParSib;
Link2->Refs.ParSib = MakeIntoParentRef(Link1);
SwapRefsButKeepFlags(Link1->Refs.Child, Link2->Refs.Child);
SetRefViaPointer(&Link1->Refs.Child, Link2);
} else {
//
// Case 5 - Link1 is an only child of link2, and
// Link2 is the root
//
Child1ParSibRef = TriAddressOfBackRefViaChild(Link1);
SetRefViaPointer(Child1ParSibRef, Link2);
Link1->Refs.ParSib = MakeIntoParentRef(Link1);
Link2->Refs.ParSib = MakeIntoParentRef(Link1);
SwapRefsButKeepFlags(Link1->Refs.Child, Link2->Refs.Child);
SetRefViaPointer(&Link1->Refs.Child, Link2);
}
} else if (TriIsLeftChild(Link1)) { // and link1 has a sibling
if (!TriIsRoot(Link2)) {
//
// Case 6 - Link1 is a left child of link2 (has a sibling), and
// Link2 is not the root
//
Child1ParSibRef = TriAddressOfBackRefViaChild(Link1);
Parent2ChildRef = TriAddressOfBackRefViaParent(Link2);
Child2ParSibRef = TriAddressOfBackRefViaChild(Link2);
SetRefViaPointer(Child1ParSibRef, Link2);
SetRefViaPointer(Parent2ChildRef, Link1);
SetRefViaPointer(Child2ParSibRef, Link1);
Link2->Refs.Child = Link1->Refs.Child;
Link1->Refs.Child = MakeIntoLeftChildRef(Link2);
SwapUlongs(Link1->Refs.ParSib, Link2->Refs.ParSib);
} else {
//
// Case 7 - Link1 is a left child of link2 (has a sibling), and
// Link2 is the root
//
Child1ParSibRef = TriAddressOfBackRefViaChild(Link1);
Child2ParSibRef = TriAddressOfBackRefViaChild(Link2);
SetRefViaPointer(Child1ParSibRef, Link2);
SetRefViaPointer(Child2ParSibRef, Link1);
Link2->Refs.Child = Link1->Refs.Child;
Link1->Refs.Child = MakeIntoLeftChildRef(Link2);
Link2->Refs.ParSib = Link1->Refs.ParSib;
Link1->Refs.ParSib = MakeIntoParentRef(Link1);
}
} else { // TriIsRightChild(Link1) and Link1 has a sibling
if (!TriIsRoot(Link2)) {
//
// Case 8 - Link1 is a right child of link2 (has a sibling), and
// Link2 is not the root
//
Parent1ChildRef = TriAddressOfBackRefViaParent(Link1);
Child1ParSibRef = TriAddressOfBackRefViaChild(Link1);
Parent2ChildRef = TriAddressOfBackRefViaParent(Link2);
SetRefViaPointer(Parent1ChildRef, Link2);
SetRefViaPointer(Child1ParSibRef, Link2);
SetRefViaPointer(Parent2ChildRef, Link1);
SwapUlongs(Link1->Refs.Child, Link2->Refs.Child);
Link1->Refs.ParSib = Link2->Refs.ParSib;
Link2->Refs.ParSib = MakeIntoParentRef(Link1);
} else {
//
// Case 9 - Link1 is a right child of link2 (has a sibling), and
// Link2 is the root
//
Parent1ChildRef = TriAddressOfBackRefViaParent(Link1);
Child1ParSibRef = TriAddressOfBackRefViaChild(Link1);
SetRefViaPointer(Parent1ChildRef, Link2);
SetRefViaPointer(Child1ParSibRef, Link2);
SwapUlongs(Link1->Refs.Child, Link2->Refs.Child);
Link1->Refs.ParSib = MakeIntoParentRef(Link1);
Link1->Refs.ParSib = MakeIntoParentRef(Link1);
}
}
}
}
void MeshParameterization::GenerateTriangleTexelData()
{
#if ENABLE_DEBUG_DEGENERATES
map< float, blah > s_DegenerateList;
#endif
//Generate texel data per triangle
const float uIncrement = 1.f/(float)m_TexSize;
const float vIncrement = 1.f/(float)m_TexSize;
const float uHalfIncrement = uIncrement*.5f;
const float vHalfIncrement = vIncrement*.5f;
ParameterizationVertex * p0;
ParameterizationVertex * p1;
ParameterizationVertex * p2;
//0 is smallest y value
//1 is smallest x value that's not 0
TriangleTextureMapping toAdd;
Vec3 barycentric;
float u;
float uMax;
for( int i = 0; i < (int)m_Faces->size(); i++ )
{
TriangleFace &tri = (*m_Faces)[ i ];
bool DangerTriangle = false;
//get verts
p0 = &(*m_CollapsedMesh)[ tri.index[ 0 ] ];
p1 = &(*m_CollapsedMesh)[ tri.index[ 1 ] ];
p2 = &(*m_CollapsedMesh)[ tri.index[ 2 ] ];
NormalizeUV( p1->generatedU );
NormalizeUV( p1->generatedV );
NormalizeUV( p2->generatedU );
NormalizeUV( p2->generatedV );
NormalizeUV( p0->generatedU );
NormalizeUV( p0->generatedV );
if( p0->generatedV > p1->generatedV )
{
SwapPointers( &p0, &p1 );
}
if( p0->generatedV > p2->generatedV )
{
SwapPointers( &p0, &p2 );
}
if( p1->generatedU > p2->generatedU )
{
SwapPointers( &p1, &p2 );
}
//find slopes
float slope1, slope2, slope3, slope4;
bool undefinedSlope[4];
undefinedSlope[0] = false;
undefinedSlope[1] = false;
undefinedSlope[2] = false;
undefinedSlope[3] = false;
if( fabs( p0->generatedV - p1->generatedV ) <= EPSILON_ZERO )
{
undefinedSlope[0] = true;
}
if( fabs( p0->generatedV - p2->generatedV ) <= EPSILON_ZERO )
{
undefinedSlope[1] = true;
}
if( fabs( p1->generatedV - p2->generatedV ) <= EPSILON_ZERO )
{
undefinedSlope[2] = true;
}
if( fabs( p2->generatedV - p1->generatedV ) <= EPSILON_ZERO )
{
undefinedSlope[3] = true;
}
slope1 = ( p0->generatedU - p1->generatedU )/(p0->generatedV - p1->generatedV );
slope2 = ( p0->generatedU - p2->generatedU )/(p0->generatedV - p2->generatedV );
slope3 = ( p1->generatedU - p2->generatedU )/(p1->generatedV - p2->generatedV );
slope4 = ( p2->generatedU - p1->generatedU )/(p2->generatedV - p1->generatedV );
float maxV = ( p1->generatedV > p2->generatedV ) ? p1->generatedV : p2->generatedV;
float maxU = ( p0->generatedU > p2->generatedU ) ? p0->generatedU : p2->generatedU;
maxU += uIncrement;
maxV += vHalfIncrement;
for( float v = p0->generatedV - vHalfIncrement; v <= maxV ; v += vIncrement )
{
if( p1->generatedV >= v &&
p2->generatedV >= v )
{
//find endpoints of scanline
u = undefinedSlope[0] ? p1->generatedU : p1->generatedU + slope1*( v - p1->generatedV ) - uHalfIncrement;
uMax = undefinedSlope[1] ? p2->generatedU : p2->generatedU + slope2*( v - p2->generatedV ) + uHalfIncrement;
}
else if( p2->generatedV <= v )
{
//find endpoints of scanline
u = undefinedSlope[0] ? p1->generatedU : p1->generatedU + slope1*( v - p1->generatedV )- uHalfIncrement;
uMax = undefinedSlope[3] ? p2->generatedU : p1->generatedU + slope4*( v - p1->generatedV ) + uHalfIncrement;
}
else // p1->v is smaller than v, we're need a new edge
{
//find endpoints of scanline
u = undefinedSlope[2] ? p1->generatedU : p2->generatedU + slope3*( v - p2->generatedV ) - uHalfIncrement;
uMax = undefinedSlope[1] ? p2->generatedU : p2->generatedU + slope2*( v - p2->generatedV ) + uHalfIncrement;
}
if( u > uMax ){ float temp = u; u = uMax; uMax = temp; }
uMax = min( uMax, maxU );
float umin = min( p1->generatedU, p0->generatedU - uIncrement);
u = max( u, umin);
for( ; u <= uMax; u+= uIncrement )
{
//we have u and v, get barycentric:
//check if slope will be undefined
float qX, qY;
float slopeBC, b2, b1, slope;
float slopeDenom = u - p0->generatedU;
float slopeDenom2 = p1->generatedU - p2->generatedU;
if( slopeDenom == 0 &&
slopeDenom2 != 0)
{
//vertical line, we know x coordinate
slopeBC = ( p1->generatedV - p2->generatedV )/( p1->generatedU - p2->generatedU );
b2 = p1->generatedV - slopeBC*p1->generatedU;
//solve for y with known x coordinate
qX = p0->generatedU;
qY = slopeBC*qX + b2;
}else if( slopeDenom2 != 0 &&
slopeDenom != 0 )
{
slope = ( v - p0->generatedV )/slopeDenom;
//find other slope, will never be undefined
slopeBC = ( p1->generatedV - p2->generatedV )/( p1->generatedU - p2->generatedU );
//now solve for intersect
b1 = v - slope*u;
b2 = p1->generatedV - slopeBC*p1->generatedU;
qX = ( b1 - b2 )/(slopeBC - slope);
qY = slope*qX + b1;
//now find length for bary
}else if( slopeDenom2 == 0 && slopeDenom != 0 )
{
slope = ( v - p0->generatedV )/slopeDenom;
//now solve for intersect
b1 = v - slope*u;
qX = p2->generatedU;
qY = slope*qX + b1;
//now find length for bary
}else //both equal 0
{
//this should never happen!
OutputDebugString("Slopes of two triangle sides are both zero!!!\n");
qX = p2->generatedU;
qY = p2->generatedV;
}
barycentric.z = Vec2Length( p1->generatedU - qX, p1->generatedV - qY );
barycentric.y = Vec2Length( p2->generatedU - qX, p2->generatedV - qY );
//now find t to balance these out at q on p
float ratio = Vec2Length( qX - u, qY - v )
/Vec2Length( u - p0->generatedU, v - p0->generatedV);
barycentric.x = ( barycentric.y + barycentric.z )*ratio;
float normalize = barycentric.x + barycentric.y + barycentric.z;
if( normalize != 0 )
{
barycentric.x /= normalize;
barycentric.y /= normalize;
barycentric.z /= normalize;
toAdd.localSpaceCoord = p0->originalPosition*barycentric.x +
p1->originalPosition*barycentric.y +
p2->originalPosition*barycentric.z;
if( toAdd.localSpaceCoord.x != toAdd.localSpaceCoord.x )
{
DangerTriangle = true;
//OutputDebugString( "DANGER WILL ROBINSON\n");
}
toAdd.localNormal = p0->normal*barycentric.x +
p1->normal*barycentric.y +
p2->normal*barycentric.z;
toAdd.u = (int)( u*(float)m_TexSize );
toAdd.v = (int)( v*(float)m_TexSize );
if( toAdd.localSpaceCoord.x == toAdd.localSpaceCoord.x &&
toAdd.u >= 0 && toAdd.u < m_TexSize &&
toAdd.v >= 0 && toAdd.v < m_TexSize )
{
tri.m_Pixels.push_back( toAdd );
}
}
}
static int numcont = 0;
numcont++;
if( DangerTriangle &&
numcont < 200 )
{
ADDLINEPARAMS LineParam;
static CHashString h(_T("none"));
LineParam.name = &h;
LineParam.blue = 0;
LineParam.green = 0;
LineParam.red = 255;
LineParam.start = p0->originalPosition;
LineParam.end = p1->originalPosition;
//static DWORD msgHash_AddLine = CHashString(_T("AddLine")).GetUniqueID();
//EngineGetToolBox()->SendMessage(msgHash_AddLine,sizeof(LineParam), &LineParam );
LineParam.start = p0->originalPosition;
LineParam.end = p2->originalPosition;
//EngineGetToolBox()->SendMessage(msgHash_AddLine,sizeof(LineParam), &LineParam );
LineParam.start = p2->originalPosition;
LineParam.end = p1->originalPosition;
//EngineGetToolBox()->SendMessage(msgHash_AddLine,sizeof(LineParam), &LineParam );
}
}
//test code
#if ENABLE_DEBUG_DEGENERATES
Vec3 edge1 = Vec3( p0->generatedU, p0->generatedV, 0 ) - Vec3( p1->generatedU, p1->generatedV, 0 );
Vec3 edge2 = Vec3( p0->generatedU, p0->generatedV, 0 ) - Vec3( p2->generatedU, p2->generatedV, 0 );
float lengthA = edge1.Length();
float lengthB = (Vec3( p1->generatedU, p1->generatedV, 0 ) - Vec3( p2->generatedU, p2->generatedV, 0 )).Length();
float lengthC = edge2.Length();
float halfPerimeter = (lengthA + lengthB + lengthC)*.500f;
float area = halfPerimeter*( halfPerimeter - lengthA )*(halfPerimeter - lengthB )*(halfPerimeter - lengthC);
area = sqrt( area );
float numPixels = (float)tri.m_Pixels.size();
edge1.Normalize();
edge2.Normalize();
float flatTriangle = edge2.Dot( edge1 );
//if( fabs( flatTriangle ) < .7f)
{
area *= (float)(m_TexSize*m_TexSize);
float areaRatio = numPixels/area;
if( areaRatio < .8f ) //half the uv pixels aren't generate?!#!
{
blah ref;
ref.area = area;
ref.pixels = (int)numPixels;
ref.index = i;
s_DegenerateList.insert( pair< float, blah >( numPixels, ref ) );
}
}
#endif
if( tri.m_Pixels.size() < 2)
{
//something wrong here
//OutputDebugString("Degenerate Triangle\n");
//OutputVector( p0->originalPosition, "p0" );
//OutputVector( p1->originalPosition, "p1" );
//OutputVector( p2->originalPosition, "p2" );
//int a = 0;
}
}
#if ENABLE_DEBUG_DEGENERATES
static char buf[1024];
for( map< float, blah >::iterator iter = s_DegenerateList.begin();
iter != s_DegenerateList.end();
++iter )
{
blah &ref = iter->second;
TriangleFace &tri = (*m_Faces)[ ref.index ];
//get verts
p0 = &(*m_CollapsedMesh)[ tri.index[ 0 ] ];
p1 = &(*m_CollapsedMesh)[ tri.index[ 1 ] ];
p2 = &(*m_CollapsedMesh)[ tri.index[ 2 ] ];
//sprintf( buf, "Degenerate Triangle with area: %f, pixels: %d, index: %d \n", ref.area, ref.pixels, ref.index );
//OutputDebugString( buf );
//OutputVector( p0->originalPosition, "p0" );
//OutputVector( p1->originalPosition, "p1" );
//OutputVector( p2->originalPosition, "p2" );
ADDLINEPARAMS LineParam;
static CHashString h(_T("none"));
LineParam.name = &h;
LineParam.blue = 0;
LineParam.green = 0;
LineParam.red = 255;
LineParam.start = p0->originalPosition;
LineParam.end = p1->originalPosition;
static DWORD msgHash_AddLine = CHashString(_T("AddLine")).GetUniqueID();
EngineGetToolBox()->SendMessage(msgHash_AddLine,sizeof(LineParam), &LineParam );
LineParam.start = p0->originalPosition;
LineParam.end = p2->originalPosition;
static DWORD msgHash_AddLine = CHashString(_T("AddLine")).GetUniqueID();
EngineGetToolBox()->SendMessage(msgHash_AddLine,sizeof(LineParam), &LineParam );
LineParam.start = p2->originalPosition;
LineParam.end = p1->originalPosition;
static DWORD msgHash_AddLine = CHashString(_T("AddLine")).GetUniqueID();
EngineGetToolBox()->SendMessage(msgHash_AddLine,sizeof(LineParam), &LineParam );
}
#endif
}
