int WritePolygons(OutputMesh mesh, int position)
{
int geometriesCount = this.curvedPolygonsNet.GetGeometriesCount();
CPNPolygon[][] polygons = tessellationOutput.GetPolygons();
int[][] polygonsProfile = tessellationOutput.GetPolygonsProfile();
int[][] polygonsVerticesProfile = tessellationOutput.GetPolygonsVerticesProfile();
for (int k = 0; k < geometriesCount; k++)
{
mesh.SetGeometry(k);
CPNGeometry geometry = this.curvedPolygonsNet.GetGeometries()[k];
int geomPolygonsCount = subSet == null?geometry.GetPolygonsCount() : subSet.polygons[k].Length;
for (int i = 0; i < geomPolygonsCount; i++)
{
int index = subSet == null ? i : subSet.polygons[k][i];
int countEffectiveSize = polygons[k][index].sideEdges.Length;
CPNPolygon polygonData = polygons[k][index];
if (countEffectiveSize > 2 && countEffectiveSize < TESSELLATION_PROCESS_NET_INTERPOLATORS &&
!polygonData.skip)
{
polygonData.computeSideEdgesSizes();
ICPNetInterpolator netInterpolator = manager.GetSchema(polygonData.schemaIndex).
interpolators[countEffectiveSize];
netInterpolator.UdpdateContent(mesh, polygonData, polygonsVerticesProfile[k][index],
polygonsProfile[k][index]);
}
}
position += polygonsVerticesProfile[k][geometry.GetPolygonsCount()];
int triangleIndex = polygonsProfile[k][geometry.GetPolygonsCount()];
int trianglesCount = geometry.GetTrianglesCount();
short[] triangles = geometry.GetTriangles();
for (int i = 0; i < trianglesCount; i++)
{
mesh.WriteTriangle(triangleIndex, triangles[3 * i], triangles[3 * i + 1], triangles[3 * i + 2]);
triangleIndex++;
}
int quadsCount = geometry.GetQuadsCount();
short[] quads = geometry.GetQuads();
for (int i = 0; i < quadsCount; i++)
{
mesh.WriteQuad(triangleIndex, quads[3 * i], quads[3 * i + 1], quads[3 * i + 2], quads[3 * i + 3]);
triangleIndex += 2;
}
}
return(position);
}
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 RetrieveInfos(CPNPolygon buildingPolygonData)
{
triangleStructure.RetrieveInfos(buildingPolygonData);
}
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 ExtractPolygonsProfile()
{
int geometriesCount = this.curvedPolygonsNet.GetGeometriesCount();
int polygonsCount = this.curvedPolygonsNet.GetTotalPolygonsCount();
CPNPolygon[][] polygonsData = tessellationOutput.InitPolygons(geometriesCount);
int[] builtTrianglesSize = tessellationOutput.GetBuiltTrianglesSize();
CPNGuide[] guides = tessellationOutput.GetGuides();
int builtVerticesSize = this.tessellationOutput.GetBuiltVerticesSize();
int[][] polygonsProfile = tessellationOutput.InitPolygonsProfile(geometriesCount);
int[][] polygonsVerticesProfile = tessellationOutput.GetPolygonsVerticesProfile();
for (int k = 0; k < geometriesCount; k++)
{
CPNGeometry geometry = this.curvedPolygonsNet.GetGeometries()[k];
int overallPolygonsPosition = 0;
int geomPolygonsCount = geometry.GetPolygonsCount();
builtTrianglesSize[k] = 0;
//geometriesProfile[k] = builtTrianglesSize;
polygonsProfile[k] = new int[geomPolygonsCount + 1];
polygonsVerticesProfile[k] = new int[geomPolygonsCount + 1];
short[] polygons = geometry.GetPolygons();
short[] schemas = geometry.polygonsSchemas;
polygonsData[k] = new CPNPolygon[geomPolygonsCount];
for (int i = 0; i < geomPolygonsCount; i++)
{
int polygonPosition = geometry.GetPolygonPosition(i);
int polygonLength = geometry.GetPolygonLength(i);
int effectivePolygonSize = 0;
for (int j = 0; j < polygonLength; j++)
{
effectivePolygonSize++;
int pIndex = polygons[polygonPosition + j];
if (pIndex == 0)
{
j += (1 + polygons[polygonPosition + j + 1]);
}
}
CPNSideEdge[] iEdges = new CPNSideEdge[effectivePolygonSize];
int effectivePolygonIndex = 0;
for (int j = 0; j < polygonLength; j++)
{
short pIndex = polygons[polygonPosition + j];
if (pIndex == 0)
{
int size = polygons[polygonPosition + j + 1];
CPNGuide[] guide = new CPNGuide[size];
bool[] direct = new bool[size];
for (int l = 0; l < size; l++)
{
int subPIndex = polygons[polygonPosition + j + 2 + l];
int edgeIndex = subPIndex > 0 ? subPIndex - 1 : -subPIndex - 1;
guide[l] = guides[edgeIndex];
direct[l] = subPIndex > 0;
}
CPNSideEdge sideEdge = new CPNSideEdge();
sideEdge.Set(guide, direct);
iEdges[effectivePolygonIndex] = sideEdge;
j += (1 + polygons[polygonPosition + j + 1]);
}
else
{
int edgeIndex = pIndex > 0 ? pIndex - 1 : -pIndex - 1;
bool direct = pIndex > 0;
CPNSideEdge sideEdge = new CPNSideEdge();
sideEdge.Set(guides[edgeIndex], direct);
iEdges[effectivePolygonIndex] = sideEdge;
}
effectivePolygonIndex++;
}
CPNPolygon polygonData = new CPNPolygon();
int id = map == null ? schemas[i] : map.GetMappedInterpolatorId(schemas[i]);
polygonData.schemaIndex = manager.GetSchemaIndex(id);
polygonsData[k][i] = polygonData;
polygonData.sideEdges = iEdges;
polygonData.computeSkip();
}
for (int i = 0; i < geomPolygonsCount; i++)
{
polygonsProfile[k][i] = builtTrianglesSize[k] + overallPolygonsPosition;
polygonsVerticesProfile[k][i] = builtVerticesSize;
CPNPolygon polygonData = polygonsData[k][i];
int polygonLength = polygonData.sideEdges.Length;
if (polygonLength > 2 && polygonLength < TESSELLATION_PROCESS_NET_INTERPOLATORS &&
!polygonData.skip)
{
ICPNetInterpolator netInterpolator = manager.GetSchema(polygonData.schemaIndex).
interpolators[polygonLength];
netInterpolator.RetrieveInfos(polygonData);
builtVerticesSize += netInterpolator.GetComputedInternals();
builtTrianglesSize[k] += netInterpolator.GetComputedTriangles();
}
}
polygonsProfile[k][geomPolygonsCount] = builtTrianglesSize[k] + overallPolygonsPosition;
polygonsVerticesProfile[k][geomPolygonsCount] = builtTrianglesSize[k];
builtTrianglesSize[k] += geometry.GetTrianglesCount();
builtTrianglesSize[k] += geometry.GetQuadsCount() << 1;
overallPolygonsPosition = polygonsProfile[k][geomPolygonsCount];
}
this.tessellationOutput.SetBuiltVerticesSize(builtVerticesSize);
}
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);
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);
}
}