public void writeWithGuideBack(CPNSideEdge guide, int N, float step, OutputMesh mesh,
CPNGuideEvaluator evaluator)
{
this.step = step;
requestSize(N + 1);
//We should have only one thickness on multisided edge, you know?
this.thickness = 1;
for (int i = 0; i <= N; i++)
{
//This is the eval-back
evaluator.EvalAt(1.0f - i * step, guide);
Vector3 dev = evaluator.EvalDev(guide);
vertices[i] = evaluator.EvalVertex(guide);
if (i == 0)
{
devFirst = dev;
}
if (i == N)
{
devLast = dev;
}
evaluator.EvalAt(i * step + DELTA, guide);
verticesDplus[i] = evaluator.EvalVertex(guide);
evaluator.EvalAt(i * step - DELTA, guide);
verticesDminus[i] = evaluator.EvalVertex(guide);
normals[i] = evaluator.EvalNormal(guide, dev).normalized;
uvs[i] = evaluator.EvalUV(guide);
for (int k = 0; k < countP; k++)
{
properties[k][i] = evaluator.EvalProperty(guide, k);
}
}
}
public Vector3 evalProperty(int k, int sIndex, CPNSideEdge sidedEdge, float t)
{
int backSIndex = prev.N - sIndex;
evaluator.EvalAt(t, sidedEdge);
Vector3 A = evaluator.EvalProperty(sidedEdge, k);
Vector3 B = prev.properties[k][backSIndex];
Vector3 C = next.properties[k][sIndex];
Vector3 A0 = buffer.properties[k][0];
Vector3 AN = buffer.properties[k][buffer.N];
float sB = 1 - prev.ts[backSIndex];
float sC = prev.ts[sIndex];
float s = (1 - t) * sB + t * sC;
float size = (1 - s) * (1 - s) * (1 - s) /* * s0[==1] */ +
(s1 * (1 - s) * (1 - s) + s2 * s * (1 - s) + s3 * s * s) * s;
//float sB = 1 - prev.ts[backSIndex];
//float sC = prev.ts[sIndex];
//float s = (1 - t) * sB + t * sC;
Vector3 At = (1 - t) * A0 + t * AN;
//Vector3 PA = A - At;
Vector3 PA = (A - At) * size;
Vector3 PBC = (1 - t) * B + t * C;
return(PA + PBC);
//return A + (1 - t) * (B - A0) + t * (C - AN);
}
public NetPolylineIndicesArray(CPNSideEdge guide, OutputMesh builder)
{
this.guide = guide;
this.builder = builder;
this.position = 0;
this.back = false;
}
public float EvalAt(float t, CPNSideEdge sideEdge)
{
int N = sideEdge.guide.Length;
float index = t * N;
this.sideEdgeIndex = (int)index;
if (sideEdgeIndex < 0)
{
sideEdgeIndex = 0;
}
if (sideEdgeIndex >= N)
{
sideEdgeIndex = N - 1;
}
t = index - this.sideEdgeIndex;
/*if(sideEdgeIndex<0 || sideEdgeIndex>=sideEdge.direct.Length)
* Debug.Log("N " + N + " sideEdgeIndex:" + sideEdgeIndex + " sideEdge.guide.Length:" + sideEdge.guide.Length
+ " this.sideEdgeIndex:"+ this.sideEdgeIndex+" t:"+t);*/
bool direct = sideEdge.direct[sideEdgeIndex];
CPNGuide guide = sideEdge.guide[sideEdgeIndex];
if (!direct)
{
t = 1 - t;
}
this.direction = direct ? 1 : -1;
float updatedT = EvalAt(t, guide);
updatedT = direct ? updatedT : 1 - updatedT;
float sideEdgeT = sideEdge.position[sideEdgeIndex] + updatedT * sideEdge.size[sideEdgeIndex];
return(sideEdgeT);
}
private Vector3 evalVertex(CPNSideEdge sidedEdgeA,
CPNSideEdge sidedEdgeB, float U, float V)
{
//int backBIndex = bufferPrev.N - Bindex;
evaluator.EvalAt(0, sidedEdgeA);
Vector3 v0 = evaluator.EvalVertex(sidedEdgeA);
Vector3 dA0 = evaluator.EvalDev(sidedEdgeA);
evaluator.EvalAt(U, sidedEdgeA);
Vector3 vA = evaluator.EvalVertex(sidedEdgeA);
Vector3 nA = evaluator.EvalNormal(sidedEdgeA);
evaluator.EvalAt(1 - V, sidedEdgeB);
Vector3 vB = evaluator.EvalVertex(sidedEdgeB);
Vector3 nB = evaluator.EvalNormal(sidedEdgeB);
evaluator.EvalAt(1, sidedEdgeB);
Vector3 dB0 = -evaluator.EvalDev(sidedEdgeB);
float kA = -Vector3.Dot(dB0, nA);
Vector3 part1 = vA + /*sidedEdgeA.guide[0].thickness **/ ((vB - v0) + kA * V * nA);
float kB = -Vector3.Dot(dA0, nB);
Vector3 part2 = vB + /*sidedEdgeB.guide[0].thickness * */ ((vA - v0) + kB * U * nB);
float U2 = U * U;
float V2 = V * V;
return((part1 * U2 + part2 * V2) / (U2 + V2));
}
private Vector3 evalUV(CPNSideEdge sidedEdgeA,
CPNSideEdge sidedEdgeB, float U, float V)
{
//int backBIndex = bufferPrev.N - Bindex;
evaluator.EvalAt(0, sidedEdgeA);
Vector3 v0 = evaluator.EvalUV(sidedEdgeA);
evaluator.EvalAt(U, sidedEdgeA);
Vector3 vA = evaluator.EvalUV(sidedEdgeA);
evaluator.EvalAt(1 - V, sidedEdgeB);
Vector3 vB = evaluator.EvalUV(sidedEdgeB);
evaluator.EvalAt(1, sidedEdgeB);
return(vB + vA - v0);
}
public Vector3 evalVertex(int sIndex, CPNSideEdge sidedEdge, float t)
{
int backSIndex = prev.N - sIndex;
evaluator.EvalAt(t, sidedEdge);
Vector3 A = evaluator.EvalVertex(sidedEdge);
Vector3 B = prev.vertices[backSIndex];
Vector3 C = next.vertices[sIndex];
Vector3 A0 = buffer.vertices[0];
Vector3 AN = buffer.vertices[buffer.N];
float sB = 1 - prev.ts[backSIndex];
float sC = prev.ts[sIndex];
float s = (1 - t) * sB + t * sC;
float size = (1 - s) * (1 - s) * (1 - s) /* * s0[==1] */ +
(s1 * (1 - s) * (1 - s) + s2 * s * (1 - s) + s3 * s * s) * s;
if (!CPNCornerSet.applySecondOrderControl)
{
size = 1;
}
Vector3 firstOrder = GetFirstOrder(t);
Vector3 At = (1 - t) * A0 + t * AN;
//Vector3 PA = A - At;
Vector3 PA = (A - At) * size;
Vector3 PBC = (1 - t) * B + t * C;
//if (CPNCornerSet.applySecondOrderControl)
//{
return(PA + PBC + firstOrder * (1 - s) * (1 - s) * s /** (1 - s * s)+
* ((1 - t) * B + t * C ) * (s * s)*/);
//}
//else
//{
// return PA+PBC;
//}
}
public NetPolylineInternalIndicesArray(CPNSideEdge sideEdge, OutputMesh builder)
{
this.sideEdge = sideEdge;
this.builder = builder;
this.position = 0;
}
public void writeWithGuideBack(CPNSideEdge guide, int N, OutputMesh mesh,
CPNGuideEvaluator evaluator)
{
writeWithGuideBack(guide, N, 1.0f / N, mesh, evaluator);
}
public Vector3 EvalAxis(CPNSideEdge sideEdge)
{
return(EvalAxis(sideEdge.guide[sideEdgeIndex]) * direction);//E' da verificare, però SI
}
public Vector3 EvalNormal(CPNSideEdge sideEdge, Vector3 Dev)
{
return(EvalNormal(sideEdge.guide[sideEdgeIndex], Dev * direction));
}
public Vector3 EvalNormal(CPNSideEdge sideEdge)
{
return(EvalNormal(sideEdge.guide[sideEdgeIndex]));
}
public Vector3 EvalProperty(CPNSideEdge sideEdge, int property)
{
return(EvalProperty(sideEdge.guide[sideEdgeIndex], property));
}
public Vector3 EvalDev(CPNSideEdge sideEdge)
{
return(direction * EvalDev(sideEdge.guide[sideEdgeIndex]));
}
public Vector3 EvalVertex(CPNSideEdge sideEdge)
{
return(EvalVertex(sideEdge.guide[sideEdgeIndex]));
}
