public void UdpdateContent(OutputMesh mesh, CPNPolygon polygon, int internalsIndex,
int facesIndex, bool doUpdateStructure = true)
{
triangleStructure.RetrieveInfos(polygon);
bool useUV = mesh.DoUseUVs();
bool useNormals = mesh.DoNormals();
bool useTangents = mesh.DoUseUVs();
int countProperties = mesh.CountProperties();
buffer0.requestProperties(countProperties);
buffer1.requestProperties(countProperties);
buffer2.requestProperties(countProperties);
int M = triangleStructure.GetM();
float step = 1.0f / M;
CPNSideEdge[] polylines = polygon.sideEdges;
buffer0.writeWithGuide(polylines[0], M, mesh, evaluator);
buffer1.writeWithGuide(polylines[1], M, mesh, evaluator);
buffer2.writeWithGuide(polylines[2], M, mesh, evaluator);
corner0.Set(buffer0, buffer2);
corner1.Set(buffer1, buffer0);
corner2.Set(buffer2, buffer1);
int position = internalsIndex;
for (int i = 1; i < M - 1; i++)
{
for (int j = 1; j < M - 1 - (i - 1); j++)
{
int wIndex = M - i - j;
float U = j * step;
float V = i * step;
float W = 1 - U - V;
float a1 = W * W;
float a2 = U * U;
float a3 = V * V;
float rec = 1.0f / (a1 + a2 + a3);
a1 *= rec;
a2 *= rec;
a3 *= rec;
Vector3 V1 = corner0.evalVertex(j, i);
Vector3 V2 = corner1.evalVertex(i, wIndex);
Vector3 V3 = corner2.evalVertex(wIndex, j);
Vector3 vertex = V1 * a1 + V2 * a2 + V3 * a3;
Vector3 normal = Vector3.zero;
Vector3 uv = Vector3.zero;
Vector3 tangent = Vector3.zero;
if (useNormals)
{
Vector3 V1N = corner0.evalNormal(j, i);
Vector3 V2N = corner1.evalNormal(i, wIndex);
Vector3 V3N = corner2.evalNormal(wIndex, j);
normal = V1N * a1 + V2N * a2 + V3N * a3;
}
if (useUV)
{
Vector3 V1uv = corner0.evalUV(j, i);
Vector3 V2uv = corner1.evalUV(i, wIndex);
Vector3 V3uv = corner2.evalUV(wIndex, j);
uv = V1uv * a1 + V2uv * a2 + V3uv * a3;
if (useTangents)
{
float Uu = U + 0.001f;
float Wu = 1 - Uu - V;
float a1u = Wu * Wu;
float a2u = Uu * Uu;
float a3u = V * V;
a1u *= rec; a2u *= rec; a3u *= rec;
float Vv = V + 0.001f;
float Wv = 1 - U - Vv;
float a1v = Wv * Wv;
float a2v = U * U;
float a3v = Vv * Vv;
a1v *= rec; a2v *= rec; a3v *= rec;
Vector3 DPu = (a1u * V1 + a2u * V2 + a3u * V3) - vertex;
Vector3 DPv = (a1v * V1 + a2v * V2 + a3v * V3) - vertex;
Vector3 DUVu = (a1u * V1uv + a2u * V2uv + a3u * V3uv) - vertex;
Vector3 DUVv = (a1v * V1uv + a2v * V2uv + a3v * V3uv) - vertex;
tangent = getTangent(DPu, DPv, DUVu, DUVv);
}
}
for (int k = 0; k < countProperties; k++)
{
Vector3 V1propK = corner0.evalUV(j, i);
Vector3 V2propK = corner1.evalUV(i, wIndex);
Vector3 V3propK = corner2.evalUV(wIndex, j);
Vector3 propK = a1 * V1propK + a2 * V2propK + a3 * V3propK;
mesh.SetProperty3(position, k, propK);
}
mesh.SetPNUV(position, vertex, normal, uv, tangent);
position++;
}
}
if (doUpdateStructure)
{
triangleStructure.CreateTriangleTessellation(mesh, internalsIndex, facesIndex, polygon);
}
}
public void UdpdateContent(OutputMesh mesh, CPNPolygon polygon, int internalsIndex,
int facesIndex, bool doUpdateStructure = true)
{
quadStructure.RetrieveInfos(polygon);
bool useUV = mesh.DoUseUVs();
bool useNormals = mesh.DoNormals();
bool useTangents = mesh.DoUseUVs();
int countProperties = mesh.CountProperties();
buffer0.requestProperties(countProperties);
buffer1.requestProperties(countProperties);
buffer2.requestProperties(countProperties);
buffer3.requestProperties(countProperties);
int MV = quadStructure.GetMV();
int MH = quadStructure.GetMH();
float stepV = 1.0f / MV;
float stepH = 1.0f / MH;
CPNSideEdge[] polylines = polygon.sideEdges;
buffer0.writeWithGuide(polylines[0], MH, mesh, evaluator);
buffer1.writeWithGuide(polylines[1], MV, mesh, evaluator);
buffer2.writeWithGuide(polylines[2], MH, mesh, evaluator);
buffer3.writeWithGuide(polylines[3], MV, mesh, evaluator);
corner0.Set(buffer0, buffer3);
corner1.Set(buffer1, buffer0);
corner2.Set(buffer2, buffer1);
corner3.Set(buffer3, buffer2);
int position = internalsIndex;
for (int i = 1; i < MV; i++)
{
for (int j = 1; j < MH; j++)
{
float U = (j) * stepH;
float V = (i) * stepV;
Vector3 V1 = corner0.evalVertex(j, i);
Vector3 V2 = corner1.evalVertex(i, MH - j);
Vector3 V3 = corner2.evalVertex(MH - j, MV - i);
Vector3 V4 = corner3.evalVertex(MV - i, j);
float UM = 1 - U;
float VM = 1 - V;
float a1 = (UM * VM * UM * VM);
float a2 = (U * VM * U * VM);
float a3 = (U * V * U * V);
float a4 = (UM * V * UM * V);
float rec = 1.0f / (a1 + a2 + a3 + a4);
a1 *= rec;
a2 *= rec;
a3 *= rec;
a4 *= rec;
Vector3 vertex = a1 * V1 + a2 * V2 + a3 * V3 + a4 * V4;
Vector3 normal = Vector3.zero;
Vector3 uv = Vector3.zero;
Vector3 tangent = Vector3.zero;
if (useNormals)
{
Vector3 V1N = corner0.evalNormal(j, i);
Vector3 V2N = corner1.evalNormal(i, MH - j);
Vector3 V3N = corner2.evalNormal(MH - j, MV - i);
Vector3 V4N = corner3.evalNormal(MV - i, j);
normal = a1 * V1N + a2 * V2N + a3 * V3N + a4 * V4N;
}
if (useUV)
{
Vector3 V1uv = corner0.evalUV(j, i);
Vector3 V2uv = corner1.evalUV(i, MH - j);
Vector3 V3uv = corner2.evalUV(MH - j, MV - i);
Vector3 V4uv = corner3.evalUV(MV - i, j);
uv = a1 * V1uv + a2 * V2uv + a3 * V3uv + a4 * V4uv;
if (useTangents)
{
float Uu = U + 0.001f;
float UMu = 1 - Uu;
float a1u = (UMu * VM * UMu * VM);
float a2u = (Uu * VM * Uu * VM);
float a3u = (Uu * V * Uu * V);
float a4u = (UMu * V * UMu * V);
a1u *= rec; a2u *= rec; a3u *= rec; a4u *= rec;
float Vv = V + 0.001f;
float VMv = 1 - Vv;
float a1v = (UM * VMv * UM * VMv);
float a2v = (U * VMv * U * VMv);
float a3v = (U * Vv * U * Vv);
float a4v = (UM * Vv * UM * Vv);
a1v *= rec; a2v *= rec; a3v *= rec; a4v *= rec;
Vector3 DPu = (a1u * V1 + a2u * V2 + a3u * V3 + a4u * V4) - vertex;
Vector3 DPv = (a1v * V1 + a2v * V2 + a3v * V3 + a4v * V4) - vertex;
Vector3 DUVu = (a1u * V1uv + a2u * V2uv + a3u * V3uv + a4u * V4uv) - vertex;
Vector3 DUVv = (a1v * V1uv + a2v * V2uv + a3v * V3uv + a4v * V4uv) - vertex;
tangent = getTangent(DPu, DPv, DUVu, DUVv);
}
}
for (int k = 0; k < countProperties; k++)
{
Vector3 V1propK = corner0.evalProperty(k, j, i);
Vector3 V2propK = corner1.evalProperty(k, i, MH - j);
Vector3 V3propK = corner2.evalProperty(k, MH - j, MV - i);
Vector3 V4propK = corner3.evalProperty(k, MV - i, j);
Vector3 propK = a1 * V1propK + a2 * V2propK + a3 * V3propK + a4 * V4propK;
mesh.SetProperty3(position, k, propK);
}
mesh.SetPNUV(position, vertex, normal, uv, tangent);
position++;
}
}
if (doUpdateStructure)
{
quadStructure.CreateQuadTessellation(mesh, internalsIndex, facesIndex, polygon);
}
}