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);
edgeSurface0.Set(buffer0, buffer2, buffer1);
edgeSurface1.Set(buffer1, buffer0, buffer2);
edgeSurface2.Set(buffer2, buffer1, buffer0);
computeCorners();
float l1 = ks[0] * ks[1] * ks[0] * ks[1];
float l2 = ks[1] * ks[2] * ks[1] * ks[2];
float l3 = ks[2] * ks[0] * ks[2] * ks[0];
prepareMemory(M, countProperties);
int position = internalsIndex;
for (int i = 1; i < M - 1; i++)
{
for (int j = 1; j < M - 1 - (i - 1); j++)
{
int k = M - i - j;
float U = j * step;
float V = i * step;
float W = 1 - U - V;
float a1 = U * U * W * W * l1 /** buffer0.thickness*/;
float a2 = V * V * U * U * l2 /** buffer1.thickness*/;
float a3 = W * W * V * V * l3 /** buffer2.thickness*/;
//float a1 = W * W;
//float a2 = U * U;
//float a3 = V * V;
if (TriangleInterpolator4.interpolationCorner != 0)
{
switch (TriangleInterpolator4.interpolationCorner)
{
case 1: a1 = 1; a2 = 0; a3 = 0; break;
case 2: a1 = 0; a2 = 1; a3 = 0; break;
case 3: a1 = 0; a2 = 0; a3 = 1; break;
}
}
float rec = 1.0f / (a1 + a2 + a3);
a1 *= rec;
a2 *= rec;
a3 *= rec;
Vector3 V1 = edgeSurface0.evalVertex(/*j,*/ i, polylines[0], U / (1 - V));
Vector3 V2 = edgeSurface1.evalVertex(/*i,*/ k, polylines[1], V / (1 - W));
Vector3 V3 = edgeSurface2.evalVertex(/*k,*/ j, polylines[2], W / (1 - U));
Vector3 vertex = V1 * a1 + V2 * a2 + V3 * a3;
int memoryIndex = j + i * (M + 1) - (((i) * (i - 1)) >> 1);
memory.vertices[memoryIndex] = vertex;
if (useUV)
{
Vector3 V1uv = edgeSurface0.evalUV(/*j,*/ i, polylines[0], U / (1 - V));
Vector3 V2uv = edgeSurface1.evalUV(/*i,*/ k, polylines[1], V / (1 - W));
Vector3 V3uv = edgeSurface2.evalUV(/*k,*/ j, polylines[2], W / (1 - U));
Vector3 uv = V1uv * a1 + V2uv * a2 + V3uv * a3;
//Vector3 vertex = V3;
//Vector3 uv = V3uv;
memory.uv[memoryIndex] = uv;
}
for (int pIndex = 0; pIndex < countProperties; pIndex++)
{
Vector3 V1prop = edgeSurface0.evalProperty(pIndex, i, polylines[0], U / (1 - V));
Vector3 V2prop = edgeSurface1.evalProperty(pIndex, k, polylines[1], V / (1 - W));
Vector3 V3prop = edgeSurface2.evalProperty(pIndex, j, polylines[2], W / (1 - U));
Vector3 prop = V1prop * a1 + V2prop * a2 + V3prop * a3;
mesh.SetProperty3(position, pIndex, prop);
}
position++;
}
}
position = internalsIndex;
for (int i = 1; i < M - 1; i++)
{
for (int j = 1; j < M - 1 - (i - 1); j++)
{
int rowIndex = i * (M + 1) - (((i) * (i - 1)) >> 1);
int rowIndexPrev = (i - 1) * (M + 1) - (((i - 1) * (i - 2)) >> 1);
int rowIndexNext = (i + 1) * (M + 1) - (((i + 1) * (i)) >> 1);
int memoryIndex = j + rowIndex;
Vector3 vertex = memory.vertices[memoryIndex];
Vector3 uv = memory.uv[memoryIndex];
Vector3 normal = Vector3.zero;
Vector3 tangent = Vector3.zero;
if (useNormals)
{
//Normal (S is the vertices, the surface)
Vector3 dSdu = memory.vertices[memoryIndex + 1] - memory.vertices[memoryIndex - 1];
Vector3 dSdv = memory.vertices[rowIndexNext + j] - memory.vertices[rowIndexPrev + j];
normal = Vector3.Cross(dSdu, dSdv).normalized;
if (useTangents)
{
//Tangent
Vector3 dTxdu = memory.uv[memoryIndex + 1] - memory.uv[memoryIndex - 1];
Vector3 dTxdv = memory.uv[rowIndexNext + j] - memory.uv[rowIndexPrev + j];
tangent = getTangent(dSdu, dSdv, dTxdu, dTxdv);
}
}
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)
{
triangleStructure.RetrieveInfos(polygon);
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);
prepareMemory(M);
for (int i = 1; i < M - 1; i++)
{
for (int j = 1; j < M - 1 - (i - 1); j++)
{
int wIndex = M - i - j;
Vector3 V1 = corner0.evalVertex(j, i);
Vector3 V1uv = corner0.evalUV(j, i);
Vector3 V2 = corner1.evalVertex(i, wIndex);
Vector3 V2uv = corner1.evalUV(i, wIndex);
Vector3 V3 = corner2.evalVertex(wIndex, j);
Vector3 V3uv = corner2.evalUV(wIndex, 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;
#if DEBUG
if (interpolationCorner != 0)
{
switch (interpolationCorner)
{
case 1: a1 = 1; a2 = 0; a3 = 0; break;
case 2: a1 = 0; a2 = 1; a3 = 0; break;
case 3: a1 = 0; a2 = 0; a3 = 1; break;
}
}
#endif
float rec = 1.0f / (a1 + a2 + a3);
a1 *= rec;
a2 *= rec;
a3 *= rec;
Vector3 vertex = V1 * a1 + V2 * a2 + V3 * a3;
Vector3 uv = V1uv * a1 + V2uv * a2 + V3uv * a3;
int memoryIndex = j + i * (M + 1) - (((i) * (i - 1)) >> 1);
memory.vertices[memoryIndex] = vertex;
memory.uv[memoryIndex] = uv;
}
}
int position = internalsIndex;
for (int i = 1; i < M - 1; i++)
{
for (int j = 1; j < M - 1 - (i - 1); j++)
{
int rowIndex = i * (M + 1) - (((i) * (i - 1)) >> 1);
int rowIndexPrev = (i - 1) * (M + 1) - (((i - 1) * (i - 2)) >> 1);
int rowIndexNext = (i + 1) * (M + 1) - (((i + 1) * (i)) >> 1);
int memoryIndex = j + rowIndex;
Vector3 vertex = memory.vertices[memoryIndex];
Vector3 uv = memory.uv[memoryIndex];
//Normal (S is the vertices, the surface)
Vector3 dSdu = memory.vertices[memoryIndex + 1] - memory.vertices[memoryIndex - 1];
Vector3 dSdv = memory.vertices[rowIndexNext + j] - memory.vertices[rowIndexPrev + j];
Vector3 normal = Vector3.Cross(dSdu, dSdv).normalized;
//Tangent
Vector3 dTxdu = memory.uv[memoryIndex + 1] - memory.uv[memoryIndex - 1];
Vector3 dTxdv = memory.uv[rowIndexNext + j] - memory.uv[rowIndexPrev + j];
Vector3 tangent = getTangent(dSdu, dSdv, dTxdu, dTxdv);
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);
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);
prepareMemory(MH, MV);
int index = internalsIndex;
for (int i = 1; i < MV; i++)
{
for (int j = 1; j < MH; j++)
{
float U = (j) * stepH;
float V = (i) * stepV;
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 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);
Vector3 vertex = a1 * V1 + a2 * V2 + a3 * V3 + a4 * V4;
int memoryIndex = j + i * (MH + 1);
memory.vertices[memoryIndex] = vertex;
if (useUV)
{
//Vector3 vertex = V3;
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);
Vector3 uv = a1 * V1uv + a2 * V2uv + a3 * V3uv + a4 * V4uv;
//Vector3 uv = V3uv;
memory.uv[memoryIndex] = uv;
}
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 vertex = V3;
Vector3 propK = a1 * V1propK + a2 * V2propK + a3 * V3propK + a4 * V4propK;
//Vector3 uv = V3uv;
mesh.SetProperty3(index, k, propK);
}
index++;
}
}
index = internalsIndex;
for (int i = 1; i < MV; i++)
{
for (int j = 1; j < MH; j++)
{
int rowIndex = i * (MH + 1);
int rowIndexPrev = (i - 1) * (MH + 1);
int rowIndexNext = (i + 1) * (MH + 1);
int memoryIndex = j + rowIndex;
Vector3 vertex = memory.vertices[memoryIndex];
Vector3 uv = memory.uv[memoryIndex];
Vector3 normal = Vector3.zero;
Vector3 tangent = Vector3.zero;
if (useNormals)
{
//Normal (S is the vertices, the surface)
Vector3 dSdu = memory.vertices[memoryIndex + 1] - memory.vertices[memoryIndex - 1];
Vector3 dSdv = memory.vertices[rowIndexNext + j] - memory.vertices[rowIndexPrev + j];
dSdu = dSdu.normalized;
dSdv = dSdv.normalized;
normal = Vector3.Cross(dSdu, dSdv).normalized;
if (useTangents)
{
//Debug.Log("dSdu: (" + dSdu.x + "," + dSdu.y + "," + dSdu.z + ") dSdv:"
// + dSdv.x + "," + dSdv.y + "," + dSdv.z + ") Vector3.Cross(dSdu, dSdv).magnitude:" + Vector3.Cross(dSdu, dSdv).magnitude);
//Debug.Log("Normal (" + normal.x + "," + normal.y + "," + normal.z + ")");
//Tangent
Vector3 dTxdu = memory.uv[memoryIndex + 1] - memory.uv[memoryIndex - 1];
Vector3 dTxdv = memory.uv[rowIndexNext + j] - memory.uv[rowIndexPrev + j];
tangent = getTangent(dSdu, dSdv, dTxdu, dTxdv);
}
}
mesh.SetPNUV(index, vertex, normal, uv, tangent);
index++;
}
}
if (doUpdateStructure)
{
quadStructure.CreateQuadTessellation(mesh, internalsIndex, facesIndex, polygon);
}
}
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)
{
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);
prepareMemory(M);
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;
int memoryIndex = j + i * (M + 1) - (((i) * (i - 1)) >> 1);
memory.vertices[memoryIndex] = vertex;
if (useUV)
{
Vector3 V1uv = corner0.evalUV(j, i);
Vector3 V2uv = corner1.evalUV(i, wIndex);
Vector3 V3uv = corner2.evalUV(wIndex, j);
Vector3 uv = V1uv * a1 + V2uv * a2 + V3uv * a3;
memory.uv[memoryIndex] = uv;
}
for (int k = 0; k < countProperties; k++)
{
Vector3 V1prop = corner0.evalProperty(k, j, i);
Vector3 V2prop = corner1.evalProperty(k, i, wIndex);
Vector3 V3prop = corner2.evalProperty(k, wIndex, j);
Vector3 prop = V1prop * a1 + V2prop * a2 + V3prop * a3;
mesh.SetProperty3(position, k, prop);
}
position++;
}
}
position = internalsIndex;
for (int i = 1; i < M - 1; i++)
{
for (int j = 1; j < M - 1 - (i - 1); j++)
{
int rowIndex = i * (M + 1) - (((i) * (i - 1)) >> 1);
int rowIndexPrev = (i - 1) * (M + 1) - (((i - 1) * (i - 2)) >> 1);
int rowIndexNext = (i + 1) * (M + 1) - (((i + 1) * (i)) >> 1);
int memoryIndex = j + rowIndex;
Vector3 vertex = memory.vertices[memoryIndex];
Vector3 uv = memory.uv[memoryIndex];
//Normal (S is the vertices, the surface)
Vector3 dSdu = memory.vertices[memoryIndex + 1] - memory.vertices[memoryIndex - 1];
Vector3 dSdv = memory.vertices[rowIndexNext + j] - memory.vertices[rowIndexPrev + j];
Vector3 normal = Vector3.Cross(dSdu, dSdv).normalized;
//Tangent
Vector3 dTxdu = memory.uv[memoryIndex + 1] - memory.uv[memoryIndex - 1];
Vector3 dTxdv = memory.uv[rowIndexNext + j] - memory.uv[rowIndexPrev + j];
Vector3 tangent = getTangent(dSdu, dSdv, dTxdu, dTxdv);
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);
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);
edgeSurface0.Set(buffer0, buffer3, buffer1);
edgeSurface1.Set(buffer1, buffer0, buffer2);
edgeSurface2.Set(buffer2, buffer1, buffer3);
edgeSurface3.Set(buffer3, buffer2, buffer0);
computeCorners();
float l1 = ks[0] * ks[1] * ks[0] * ks[1];
float l2 = ks[1] * ks[2] * ks[1] * ks[2];
float l3 = ks[2] * ks[3] * ks[2] * ks[3];
float l4 = ks[3] * ks[0] * ks[3] * ks[0];
prepareMemory(MH, MV);
for (int i = 1; i < MV; i++)
{
for (int j = 1; j < MH; j++)
{
float U = (j) * stepH;
float V = (i) * stepV;
Vector3 V1 = edgeSurface0.evalVertex(j, i);
Vector3 V2 = edgeSurface1.evalVertex(i, MH - j);
Vector3 V3 = edgeSurface2.evalVertex(MH - j, MV - i);
Vector3 V4 = edgeSurface3.evalVertex(MV - i, j);
Vector3 V1uv = edgeSurface0.evalUV(j, i);
Vector3 V2uv = edgeSurface1.evalUV(i, MH - j);
Vector3 V3uv = edgeSurface2.evalUV(MH - j, MV - i);
Vector3 V4uv = edgeSurface3.evalUV(MV - i, j);
float UM = 1 - U;
float VM = 1 - V;
float a1 = U * U * VM * VM * UM * UM * l1 /** buffer0.thickness*/;
float a2 = VM * VM * U * U * V * V * l2 /** buffer1.thickness*/;
float a3 = UM * UM * V * V * U * U * l3 /** buffer2.thickness*/;
float a4 = V * V * UM * UM * VM * VM * l4 /** buffer3.thickness*/;
#if DEBUG
if (TriangleInterpolator4.interpolationCorner != 0)
{
switch (TriangleInterpolator4.interpolationCorner)
{
case 1: a1 = 1; a2 = 0; a3 = 0; a4 = 0; break;
case 2: a1 = 0; a2 = 1; a3 = 0; a4 = 0; break;
case 3: a1 = 0; a2 = 0; a3 = 1; a4 = 0; break;
case 4: a1 = 0; a2 = 0; a3 = 0; a4 = 1; break;
}
}
#endif
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 vertex = V3;
Vector3 uv = a1 * V1uv + a2 * V2uv + a3 * V3uv + a4 * V4uv;
//Vector3 uv = V3uv;
int memoryIndex = j + i * (MH + 1);
memory.vertices[memoryIndex] = vertex;
memory.uv[memoryIndex] = uv;
}
}
int index = internalsIndex;
for (int i = 1; i < MV; i++)
{
for (int j = 1; j < MH; j++)
{
int rowIndex = i * (MH + 1);
int rowIndexPrev = (i - 1) * (MH + 1);
int rowIndexNext = (i + 1) * (MH + 1);
int memoryIndex = j + rowIndex;
Vector3 vertex = memory.vertices[memoryIndex];
Vector3 uv = memory.uv[memoryIndex];
//Normal (S is the vertices, the surface)
Vector3 dSdu = memory.vertices[memoryIndex + 1] - memory.vertices[memoryIndex - 1];
Vector3 dSdv = memory.vertices[rowIndexNext + j] - memory.vertices[rowIndexPrev + j];
dSdu = dSdu.normalized;
dSdv = dSdv.normalized;
Vector3 normal = Vector3.Cross(dSdu, dSdv).normalized;
//Debug.Log("dSdu: (" + dSdu.x + "," + dSdu.y + "," + dSdu.z + ") dSdv:"
// + dSdv.x + "," + dSdv.y + "," + dSdv.z + ") Vector3.Cross(dSdu, dSdv).magnitude:" + Vector3.Cross(dSdu, dSdv).magnitude);
//Debug.Log("Normal (" + normal.x + "," + normal.y + "," + normal.z + ")");
//Tangent
Vector3 dTxdu = memory.uv[memoryIndex + 1] - memory.uv[memoryIndex - 1];
Vector3 dTxdv = memory.uv[rowIndexNext + j] - memory.uv[rowIndexPrev + j];
Vector3 tangent = getTangent(dSdu, dSdv, dTxdu, dTxdv);
mesh.SetPNUV(index, vertex, normal, uv, tangent);
index++;
}
}
if (doUpdateStructure)
{
quadStructure.CreateQuadTessellation(mesh, internalsIndex, facesIndex, polygon);
}
}
public void UdpdateContent(OutputMesh mesh, CPNPolygon buildingPolygonData, int internalsIndex,
int facesIndex, bool doUpdateStructure = true)
{
RetrieveInfos(buildingPolygonData);
this.step = 1.0f / M;
totalInterpolationStep = M / relativeTriangleFactorX;
interpolationSteps = (int)(totalInterpolationStep);
if (interpolationSteps * relativeTriangleFactorX < M)
{
interpolationSteps++;
}
Vector3 vertex = Vector3.zero;
Vector3 uv = Vector3.zero;
int centerPiecePosition = 0;
int verticesLayer = 0;// mesh.FindLayer(BufferType.VERTICES);
//int normalsLayer = mesh.FindLayer(BufferType.NORMALS);
//cornerSurfacesSet.SetNormalsLayer(normalsLayer);
CPNSideEdge[] polylines = buildingPolygonData.sideEdges;
for (int i = 0; i < sides; i++)
{
buffers[i].writeWithGuide(polylines[i], interpolationSteps, step * relativeTriangleFactorX, mesh, evaluator);
backBuffers[i].writeWithGuideBack(polylines[i], interpolationSteps, step * relativeTriangleFactorX, mesh, evaluator);
}
prepareMemory(M, polylines, mesh);
//int position = internalsIndex;
int triangleSize = ((M)*(M + 1)) >> 1;
for (int corner = 0; corner < sides; corner++)
{
int next = corner == sides - 1 ? 0 : corner + 1;
float p1x = cos_[corner];
float p2x = cos_[next];
float p1y = sin_[corner];
float p2y = sin_[next];
int relativeMemoryIndex = triangleSize * corner + M;
for (int i = 1; i <= M - 1; i++)
{
for (int j = 0; j <= M - 1 - i; j++)
{
float innerU = step * j;
float innerV = step * i;
float innerW = 1 - innerU - innerV;
float innerX_ = innerW * p1x + innerU * p2x;
float innerY_ = innerW * p1y + innerU * p2y;
vertex = EvalVertex(mesh, buildingPolygonData, innerX_, innerY_, out uv);
memory.vertices[relativeMemoryIndex] = vertex;
memory.uv[relativeMemoryIndex] = uv;
relativeMemoryIndex++;
//position++;
}
}
}
vertex = EvalVertex(mesh, buildingPolygonData, 0, 0, out uv);
//mesh.SetValue(0, position, vertex);
memory.vertices[triangleSize * sides] = vertex;
memory.uv[triangleSize * sides] = uv;
//position++;
//Phase 2 Normals and Tangents Evaluation
int position = internalsIndex;
for (int corner = 0; corner < sides; corner++)
{
int prev = corner == 0 ? sides - 1 : corner - 1;
int next = corner == sides - 1 ? 0 : corner + 1;
int relativeMemoryIndex = triangleSize * corner;
int nextPatchRelativeMemoryIndex = triangleSize * next;
int prevPatchRelativeMemoryIndex = triangleSize * prev;
slicePosition[corner] = position;
for (int i = 1; i <= M - 1; i++)
{
for (int j = 0; j <= M - 1 - i; j++)
{
int rowIndex = relativeMemoryIndex + M * i - (((i) * (i - 1)) >> 1);
int prevRowIndex = relativeMemoryIndex + M * (i - 1) - (((i - 1) * (i - 2)) >> 1);
int nextRowIndex = relativeMemoryIndex + M * (i + 1) - (((i + 1) * (i)) >> 1);
int index = rowIndex + j;
vertex = memory.vertices[index];
uv = memory.uv[index];
int duIndexA = 0, duIndexB = 0, dvIndexA = 0, dvIndexB = 0;
if (j > 0 && j < M - 1 - i)
{
duIndexA = prevRowIndex + j;
duIndexB = nextRowIndex + j;
dvIndexA = nextRowIndex + j - 1;
dvIndexB = prevRowIndex + j + 1;
}
else if (i < M - 1)
{
if (j == M - 1 - i)
{
int nextPatchnextRowIndex = nextPatchRelativeMemoryIndex + M * (i + 1) - (((i + 1) * (i)) >> 1);
duIndexA = prevRowIndex + j;
duIndexB = nextPatchnextRowIndex;
dvIndexA = nextRowIndex + j - 1;
dvIndexB = prevRowIndex + j + 1;
}
else if (j == 0)
{
int prevPatchprevRowIndex = prevPatchRelativeMemoryIndex + M * (i - 1) - (((i - 1) * (i - 2)) >> 1);
duIndexA = prevRowIndex + j;
duIndexB = nextRowIndex + j;
dvIndexA = prevPatchprevRowIndex + M - i;
dvIndexB = prevRowIndex + j + 1;
}
}
else
{
int prevPatchprevRowIndex = prevPatchRelativeMemoryIndex + M * (i - 1) - (((i - 1) * (i - 2)) >> 1);
duIndexA = prevRowIndex + j;
duIndexB = triangleSize * sides;
dvIndexA = prevPatchprevRowIndex + M - i;
dvIndexB = prevRowIndex + j + 1;
}
Vector3 dSdu = memory.vertices[duIndexB] - memory.vertices[duIndexA];
Vector3 dSdv = memory.vertices[dvIndexB] - memory.vertices[dvIndexA];
Vector3 normal = Vector3.Cross(dSdu, dSdv).normalized;
//Tangent
Vector3 dTxdu = memory.uv[duIndexB] - memory.uv[duIndexA];
Vector3 dTxdv = memory.uv[dvIndexB] - memory.uv[dvIndexA];
Vector3 tangent = getTangent(dSdu, dSdv, dTxdu, dTxdv);
mesh.SetPNUV(position, vertex, normal, uv, tangent);
//relativeMemoryIndex++;
position++;
}
}
}
{
int duIndexA = 2 * triangleSize - 1;
int duIndexB = 4 * triangleSize - 1;
int dvIndexA = triangleSize - 1;
int dvIndexB = 3 * triangleSize - 1;
vertex = memory.vertices[triangleSize * sides];
uv = memory.uv[triangleSize * sides];
Vector3 dSdu = memory.vertices[duIndexB] - memory.vertices[duIndexA];
Vector3 dSdv = memory.vertices[dvIndexB] - memory.vertices[dvIndexA];
Vector3 normal = Vector3.Cross(dSdu, dSdv).normalized;
//Tangent
Vector3 dTxdu = memory.uv[duIndexB] - memory.uv[duIndexA];
Vector3 dTxdv = memory.uv[dvIndexB] - memory.uv[dvIndexA];
Vector3 tangent = getTangent(dSdu, dSdv, dTxdu, dTxdv);
mesh.SetPNUV(position, vertex, normal, uv, tangent);
}
centerPiecePosition = position;
position++;
int trPosition = facesIndex;
for (int corner = 0; corner < sides; corner++)
{
int next = corner == sides - 1 ? 0 : corner + 1;
if (M > 1)
{
int rowPosition1 = slicePosition[corner];
int rowPosition2 = slicePosition[corner] + M - 1;
int rowPosition1Next = slicePosition[next];
int rowPosition2Next = slicePosition[next] + M - 1;
for (int i = 0; i < M - 2; i++)
{
for (int j_ = 0; j_ < M - 3 - i; j_++)
{
trPosition = mesh.WriteTriangle(trPosition, rowPosition1 + j_, rowPosition2 + j_, rowPosition1 + j_ + 1);
trPosition = mesh.WriteTriangle(trPosition, rowPosition1 + j_ + 1, rowPosition2 + j_, rowPosition2 + j_ + 1);
}
int j = M - 3 - i;
trPosition = mesh.WriteTriangle(trPosition, rowPosition1 + j,
rowPosition2 + j, rowPosition1 + j + 1);
trPosition = mesh.WriteTriangle(trPosition, rowPosition2 + j,
rowPosition2Next, rowPosition1 + j + 1);
trPosition = mesh.WriteTriangle(trPosition, rowPosition1 + j + 1,
rowPosition2Next, rowPosition1Next);
rowPosition1 = rowPosition2;
rowPosition2 = rowPosition2 + M - 2 - i;
rowPosition1Next = rowPosition2Next;
rowPosition2Next = rowPosition2Next + M - 2 - i;
}
trPosition = mesh.WriteTriangle(trPosition, rowPosition1, centerPiecePosition, rowPosition1Next);
meshIndicesArray.Setup(slicePosition[corner], 1, M, slicePosition[next], mesh, verticesLayer);
int polylineIndex = sides - 1 - corner;
NetPolylineIndicesArray npi = new NetPolylineIndicesArray(polylines[polylineIndex], mesh, true);
trPosition = MeshStructures.CreateSideTriangles(mesh, npi, meshIndicesArray,
trPosition);
}
else
{
trPosition = mesh.WriteTriangle(trPosition, polylines[corner].GetIndex(0), centerPiecePosition, polylines[corner].GetBackIndex(0));
}
}
}
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);
edgeSurface0.Set(buffer0, buffer3, buffer1);
edgeSurface1.Set(buffer1, buffer0, buffer2);
edgeSurface2.Set(buffer2, buffer1, buffer3);
edgeSurface3.Set(buffer3, buffer2, buffer0);
//float l1 = ks[0] * ks[1] * ks[0] * ks[1];
//float l2 = ks[1] * ks[2] * ks[1] * ks[2];
//float l3 = ks[2] * ks[3] * ks[2] * ks[3];
//float l4 = ks[3] * ks[0] * ks[3] * ks[0];
float l1 = GetBufferLength(buffer0);
float l2 = GetBufferLength(buffer1);
float l3 = GetBufferLength(buffer2);
float l4 = GetBufferLength(buffer3);
prepareMemory(MH, MV);
int index = internalsIndex;
for (int i = 1; i < MV; i++)
{
for (int j = 1; j < MH; j++)
{
float U = (j) * stepH;
float V = (i) * stepV;
float UM = 1 - U;
float VM = 1 - V;
float a1 = U * U * VM * VM * UM * UM * l1 /** buffer0.thickness*/;
float a2 = VM * VM * U * U * V * V * l2 /** buffer1.thickness*/;
float a3 = UM * UM * V * V * U * U * l3 /** buffer2.thickness*/;
float a4 = V * V * UM * UM * VM * VM * l4 /** buffer3.thickness*/;
#if DEBUG
if (TriangleInterpolator4.interpolationCorner != 0)
{
switch (TriangleInterpolator4.interpolationCorner)
{
case 1: a1 = 1; a2 = 0; a3 = 0; a4 = 0; break;
case 2: a1 = 0; a2 = 1; a3 = 0; a4 = 0; break;
case 3: a1 = 0; a2 = 0; a3 = 1; a4 = 0; break;
case 4: a1 = 0; a2 = 0; a3 = 0; a4 = 1; break;
}
}
#endif
float rec = 1.0f / (a1 + a2 + a3 + a4);
a1 *= rec;
a2 *= rec;
a3 *= rec;
a4 *= rec;
Vector3 V1 = edgeSurface0.evalVertex(j, i);
Vector3 V2 = edgeSurface1.evalVertex(i, MH - j);
Vector3 V3 = edgeSurface2.evalVertex(MH - j, MV - i);
Vector3 V4 = edgeSurface3.evalVertex(MV - i, j);
Vector3 vertex = a1 * V1 + a2 * V2 + a3 * V3 + a4 * V4;
int memoryIndex = j + i * (MH + 1);
memory.vertices[memoryIndex] = vertex;
if (useUV)
{
Vector3 V1uv = edgeSurface0.evalUV(j, i);
Vector3 V2uv = edgeSurface1.evalUV(i, MH - j);
Vector3 V3uv = edgeSurface2.evalUV(MH - j, MV - i);
Vector3 V4uv = edgeSurface3.evalUV(MV - i, j);
//Vector3 vertex = V3;
Vector3 uv = a1 * V1uv + a2 * V2uv + a3 * V3uv + a4 * V4uv;
//Vector3 uv = V3uv;
memory.uv[memoryIndex] = uv;
}
for (int k = 0; k < countProperties; k++)
{
Vector3 V1propK = edgeSurface0.evalProperty(k, j, i);
Vector3 V2propK = edgeSurface1.evalProperty(k, i, MH - j);
Vector3 V3propK = edgeSurface2.evalProperty(k, MH - j, MV - i);
Vector3 V4propK = edgeSurface3.evalProperty(k, MV - i, j);
Vector3 propK = a1 * V1propK + a2 * V2propK + a3 * V3propK + a4 * V4propK;
mesh.SetProperty3(index, k, propK);
}
index++;
}
}
index = internalsIndex;
for (int i = 1; i < MV; i++)
{
for (int j = 1; j < MH; j++)
{
int rowIndex = i * (MH + 1);
int rowIndexPrev = (i - 1) * (MH + 1);
int rowIndexNext = (i + 1) * (MH + 1);
int memoryIndex = j + rowIndex;
Vector3 vertex = memory.vertices[memoryIndex];
Vector3 uv = memory.uv[memoryIndex];
Vector3 normal = Vector3.zero;
Vector3 tangent = Vector3.zero;
if (useNormals)
{
Vector3 dSdu = memory.vertices[memoryIndex + 1] - memory.vertices[memoryIndex - 1];
Vector3 dSdv = memory.vertices[rowIndexNext + j] - memory.vertices[rowIndexPrev + j];
dSdu = dSdu.normalized;
dSdv = dSdv.normalized;
normal = Vector3.Cross(dSdu, dSdv).normalized;
if (useTangents)
{
//Tangent
Vector3 dTxdu = memory.uv[memoryIndex + 1] - memory.uv[memoryIndex - 1];
Vector3 dTxdv = memory.uv[rowIndexNext + j] - memory.uv[rowIndexPrev + j];
tangent = getTangent(dSdu, dSdv, dTxdu, dTxdv);
}
}
mesh.SetPNUV(index, vertex, normal, uv, tangent);
index++;
}
}
if (doUpdateStructure)
{
quadStructure.CreateQuadTessellation(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);
}
}