public void EvaluatePolyline(CurvedPolygonsNet net, OutputMesh mesh, CPNGuide guide)
{
bool uvAvailable = net.GetUv() != null && net.GetUv().Length != 0 && mesh.DoUseUVs();
int countP = mesh.CountProperties();
//bool tgAvailable = net.GetTangents() != null && net.GetTangents().Length != 0;
short[] tessellationDegrees = CPNGuide_loqs;
guide.vBuffer = CreateBufferWithIndices(guide.vBuffer, net.GetVertices(), guide.GetIndices());
guide.nBuffer = CreateBufferWithIndices(guide.vBuffer, net.GetNormals(), guide.GetIndices());
if (uvAvailable)
{
guide.uvsBuffer = CreateBufferWithIndices(guide.uvsBuffer, net.GetUv(), guide.GetIndices());
}
if (countP > 0)
{
guide.PreparePropertiesBuffers(countP);
for (int k = 0; k < countP; k++)
{
guide.propertiesBuffer[k] = CreateBufferWithIndices(guide.propertiesBuffer[k],
net.GetProperties3()[k], guide.GetIndices());
}
}
}
public Vector3 EvalAxis(CPNGuide guide)
{
if (guide.GetN() == -1)
{
int N = guide.GetIndices().Length;
if (N > 0)
{
Vector3 pDev1 = (guide.vBuffer[1] - guide.vBuffer[0]).normalized;
Vector3 pPerp1 = Vector3.Cross(pDev1, guide.nBuffer[0]).normalized;
Vector3 pDev2 = (guide.vBuffer[N - 1] - guide.vBuffer[N - 2]).normalized;
Vector3 pPerp2 = Vector3.Cross(pDev2, guide.nBuffer[N - 1]).normalized;
Vector3 pPerp = ((T1 + T2) * pPerp1 + (T3 + T4) * pPerp2);
return(pPerp.normalized);
}
else
{
return(Vector3.zero);
}
}
Vector3 Dev1 = (guide.vBuffer[1] - guide.vBuffer[0]).normalized;
Vector3 Perp1 = Vector3.Cross(Dev1, guide.firstNormal).normalized;
Vector3 Dev2 = (guide.vBuffer[3] - guide.vBuffer[2]).normalized;
Vector3 Perp2 = Vector3.Cross(Dev2, guide.lastNormal).normalized;
Vector3 Perp = ((T1 + T2) * Perp1 + (T3 + T4) * Perp2);
return(Perp.normalized);
}
/*
* if (linear) { //forgot linear evaluation.. uff.
* mesh.SetVertex(index, vBuffer[0] * t + vBuffer[1] * tm);
* if (uvAvailable)
* mesh.SetUV(index, uvsBuffer[0] * t + uvsBuffer[1] * tm);
* if (nsAvailable)
* {
*
* Vector3 Dev = vBuffer[1] - vBuffer[0];
* Vector3 Perp = ((1 - t) * perpA + t * perpB).normalized;
*
* Vector3 normal = Vector3.Normalize(Vector3.Cross(Dev, Perp)).normalized;
*
* mesh.SetNormal(index, normal);
* }
* }*/
public float EvalAt(float t, CPNGuide guide)
{
if (guide.GetN() == -1) //Polylines
{
int N = guide.GetIndices().Length - 1;
if (N > 1)
{
float T = t * N;
int pI = (int)T;
pI = (pI == N) ? pI - 1 : pI;
this.polylineIndex = pI;
this.T2 = T - pI;
this.T1 = 1 - this.T2;
}
else
{
this.polylineIndex = 0;
}
return(t);
}
float j = t * guide.GetN();
t = j * (guide.tessellationStepA + j * guide.tessellationStepB);
this.t = t;
this.tm = 1 - this.t;
this.T1 = tm * tm * tm;
this.T2 = 3 * t * tm * tm;
this.T3 = 3 * t * t * tm;
this.T4 = t * t * t;
float w2 = guide.w2;
float w3 = guide.w3;
this.G = (T1 + T2 * w2 + T3 * w3 + T4);
this.recG = 1.0f / G;
return(t);
}
public Vector3 EvalDev(CPNGuide guide)
{
if (guide.GetN() == -1)
{
return((guide.vBuffer[this.polylineIndex + 1] - guide.vBuffer[this.polylineIndex]) * (guide.GetIndices().Length - 1));
}
float tp = t + 0.001f;
float tmp = 1 - tp;
float T1p = tmp * tmp * tmp;
float T2p = 3 * tp * tmp * tmp;
float T3p = 3 * tp * tp * tmp;
float T4p = tp * tp * tp;
float w2 = guide.w2;
float w3 = guide.w3;
Vector3[] vBuffer = guide.vBuffer;
Vector3 F1 = (vBuffer[0] * T1 + vBuffer[1] * T2 * w2 + vBuffer[2] * T3 * w3 + vBuffer[3] * T4) /
(T1 + T2 * w2 + T3 * w3 + T4);
Vector3 F2 = (vBuffer[0] * T1p + vBuffer[1] * T2p * w2 + vBuffer[2] * T3p * w3 + vBuffer[3] * T4p) /
(T1p + T2p * w2 + T3p * w3 + T4p);
return((F2 - F1) * (1000f));
}
