public void writeWithInterpolationBuffer(InterpolationBuffer buffer, Vector3 prevDevOut, Vector3 postDevOut) { requestSize(buffer.N + 1); for (int i = 0; i <= buffer.N; i++) { //cyForward[i] = new CPIMatrix(buffer.normals[i], buffer.devs[i], prevDevOut); //cyBackward[i] = new CPIMatrix(buffer.normals[i], buffer.devs[i], postDevOut); cyForward[i] = new CPIMatrix(buffer.normals[i], buffer.normals[0], prevDevOut); cyBackward[i] = new CPIMatrix(buffer.normals[i], buffer.normals[buffer.N], postDevOut); } }
public void Set(InterpolationBuffer buffer, InterpolationBuffer prev, InterpolationBuffer next) { this.buffer = buffer; this.prev = prev; this.next = next; //s0 = 1; Vector3 A0 = buffer.vertices[0]; Vector3 AN = buffer.vertices[buffer.N]; Vector3 B = prev.vertices[0]; Vector3 C = next.vertices[next.N]; //Vector3 B_AB = A0 - CPNGuideEvaluator.ONE_THIRD * prev.devLast; Vector3 B_BA = B + CPNGuideEvaluator.ONE_THIRD * prev.devFirst; //Vector3 C_AB = AN + CPNGuideEvaluator.ONE_THIRD * next.devFirst; Vector3 C_BA = C - CPNGuideEvaluator.ONE_THIRD * next.devLast; s1 = 3; s2 = 3; s3 = 1; //float distance0 = Vector3.Distance(A0, AN); float distance0 = Vector3.Dot(A0 - AN, A0 - AN); if (distance0 > 0) { //this.s1 = 1.5f + 1.5f * Vector3.Dot(B_AB - C_AB, B_AB - C_AB) / distance0; //this.s2 = 1.5f + 1.5f * (Vector3.Dot(B_BA - C_BA, B_BA - C_BA) / distance0); this.s3 = Vector3.Dot(B - C, B - C) / distance0; //this.s1 = 3.0f + 0.0f * Vector3.Dot(B_AB - C_AB, B_AB - C_AB) / distance0; this.s2 = (3f - ShapeControlValue) + ShapeControlValue * (Vector3.Dot(B_BA - C_BA, B_BA - C_BA) / distance0); } firtsOrder = new Vector3[buffer.N + 1]; Vector3 DBs = -prev.devLast; Vector3 DCs = next.devFirst; Vector3 N0 = buffer.normals[0]; Vector3 NN = buffer.normals[buffer.N]; Vector3 axis0 = buffer.axis[0]; Vector3 axisN = buffer.axis[buffer.N]; float step = buffer.step; //So: now the 'First order' is wrong. for (int i = 0; i < firtsOrder.Length; i++) { float t = i * step; Vector3 delta = (1 - t) * DBs + t * DCs; Vector3 A = buffer.vertices[i]; Vector3 N = buffer.normals[i]; Vector3 axis = buffer.axis[i]; //firtsOrder[i] = getFirstOrder(N, N0, NN, DBs, DCs, axis0, axisN, axis, t); //private Vector3 getFirstOrder(Vector3 N, Vector3 N0, Vector3 NN, Vector3 DB0, Vector3 DBN, // Vector3 axis0, Vector3 axisN, Vector3 axis, float t) //{ //Vector3 At = (1 - t) * A0 + t * AN; //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)*/; Vector3 Delta = DBs * (1 - t) + DCs * t + (s1 - 3) * (A - A0 * (1 - t) - AN * t); Vector3 CorrectDelta = Delta * buffer.thickness - Vector3.Dot(N, Delta) * N; firtsOrder[i] = CorrectDelta - Delta; } }
public void Set(InterpolationBuffer bufferA, InterpolationBuffer bufferB) { this.bufferA = bufferA; this.bufferB = bufferB; int sizeA = bufferA.N; int sizeB = bufferB.N; if (cyA.Length < sizeA + 1) { cyA = new CurvedCorrection[sizeA + 1]; } if (cyB.Length < sizeB + 1) { cyB = new CurvedCorrection[sizeB + 1]; } Vector3 v0 = bufferA.vertices[0]; Vector3 normal0 = bufferA.normals[0]; Vector3 DA0 = bufferA.devFirst; Vector3 DB0 = -bufferB.devLast; for (int i = 0; i <= sizeA; i++) { cyA[i] = new CurvedCorrection(bufferA.normals[i], normal0, DB0, v0, bufferA.vertices[i], bufferA.devs[i], bufferA.axis[0], bufferA.axis[i]); } for (int backBIndex = 0; backBIndex <= sizeB; backBIndex++) { cyB[backBIndex] = new CurvedCorrection(bufferB.normals[backBIndex], normal0, DA0, v0, bufferB.vertices[backBIndex], bufferB.devs[backBIndex], -bufferB.axis[sizeB], -bufferB.axis[backBIndex]); } Vector3 finalA = bufferA.vertices[bufferA.N]; Vector3 finalNA = bufferA.normals[bufferA.N]; Vector3 finalB = bufferB.vertices[0]; Vector3 finalNB = bufferB.normals[0]; finalAB = (finalB - finalA) * 0.333333f; finalBA = -finalAB; finalAB = finalAB - Vector3.Dot(finalAB, finalNA) * finalNA; finalBA = finalBA - Vector3.Dot(finalBA, finalNB) * finalNB; float distance = Vector3.Distance(finalA, finalB) * 0.707107f; finalAB = finalAB * (0.58578643762f) * distance / finalAB.magnitude; finalBA = finalBA * (0.58578643762f) * distance / finalBA.magnitude; float weight = 0.80473785f; finalAB = finalAB + finalA; finalBA = finalBA + finalB; float t = 0; int index = 0; for (int i = 0; i <= sizeA; i++) { int Aindex = i; float U = bufferA.ts[Aindex]; float V = 1 - U;//This is pretty important. Vector3 vA = bufferA.vertices[Aindex]; GetInterpolation(1 - V, bufferB.N, out t, out index); Vector3 vB = bufferB.vertices[index] * (1 - t) + bufferB.vertices[index + 1] * (t); Vector3 firstOrder = cyA[Aindex].firstOrder; Vector3 finalPosition = vA + vB - v0 + firstOrder * V; Vector3 realFinalPosition = (U * U * U * finalA + 3 * U * U * V * weight * finalAB + 3 * U * V * V * weight * finalBA + V * V * V * finalB) / (U * U * U + 3 * U * U * V * weight + 3 * U * V * V * weight + V * V * V); cyA[Aindex].secondOrder2 = realFinalPosition - finalPosition; cyA[Aindex].secondOrder2 *= cyA[Aindex].secondOrderCorrectorModulation; cyA[Aindex].secondOrder2Factor = i == sizeA ? 0 : 1 / V; } for (int i = 0; i <= sizeB; i++) { int backBIndex = bufferB.N - i; float V = 1 - bufferB.ts[backBIndex]; float U = 1 - V; Vector3 vB = bufferB.vertices[backBIndex]; GetInterpolation(U, bufferA.N, out t, out index); Vector3 vA = bufferA.vertices[index] * (1 - t) + bufferA.vertices[index + 1] * (t); Vector3 firstOrder = cyB[backBIndex].firstOrder; Vector3 finalPosition = vB + vA - v0 + firstOrder * U; Vector3 realFinalPosition = (U * U * U * finalA + 3 * U * U * V * weight * finalAB + 3 * U * V * V * weight * finalBA + V * V * V * finalB) / (U * U * U + 3 * U * U * V * weight + 3 * U * V * V * weight + V * V * V); cyB[backBIndex].secondOrder2 = realFinalPosition - finalPosition; cyB[backBIndex].secondOrder2 *= cyB[backBIndex].secondOrderCorrectorModulation; cyB[backBIndex].secondOrder2Factor = i == sizeB ? 0 : 1 / U; } }
public void Set(InterpolationBuffer buffer, InterpolationBuffer prev, InterpolationBuffer next) { this.buffer = buffer; this.prev = prev; this.next = next; //s0 = 1; //Normal and Vector at the beginnig of A (where B begins) Vector3 A0 = buffer.vertices[0]; Vector3 A0N = buffer.normals[0]; //Normal and Vector at the end of A (A Final, where C begins) Vector3 AF = buffer.vertices[buffer.N]; Vector3 AFN = buffer.normals[buffer.N]; //Normal and Vector on the opposite end of B (B Final) Vector3 BNF = prev.normals[0]; Vector3 BF = prev.vertices[0]; //Normal and Vector on the opposite end of C (C Final) Vector3 CNF = next.normals[next.N]; Vector3 CF = next.vertices[next.N]; BTransforms = new CPDerivativeRotationMatrix[buffer.N + 1]; CTransforms = new CPDerivativeRotationMatrix[buffer.N + 1]; resize = new float[buffer.N + 1]; // Vector3 Ortho = AF - A0; //CPNormalsRotationMatrix BFRot = new CPNormalsRotationMatrix(A0N, BNF, Ortho); //CPNormalsRotationMatrix CFRot = new CPNormalsRotationMatrix(AFN,CNF, Ortho); float BResize = Vector3.Dot(buffer.devFirst.normalized, -prev.devLast.normalized); float CResize = Vector3.Dot(-buffer.devLast.normalized, next.devFirst.normalized); BResize = 1 - BResize * 0.5f; CResize = 1 - CResize * 0.5f; //Distance between BF and A0 //float sizeB = Vector3.Magnitude(BF - A0); //Distance between CF and AF //float sizeC = Vector3.Magnitude(CF - AF); Vector3 DB0 = -prev.devLast.normalized; Vector3 DC0 = next.devFirst.normalized; float step = 1.0f / buffer.N; for (int i = 0; i <= buffer.N; i++) { Vector3 normal = buffer.normals[i]; BTransforms[i] = new CPDerivativeRotationMatrix(normal, DB0); CTransforms[i] = new CPDerivativeRotationMatrix(normal, DC0); float t = i * step; float tm = 1 - t; //resize[i] = t * t * t + tm * tm * tm + 3 * t * tm * (tm * BResize + t * CResize); //Anche questo resize è inutile sai? resize[i] = t * t + tm * tm + 2 * t * tm * (BResize + CResize); resize[i] = 1; //Vector3 A = buffer.vertices[i]; //Vector3 AB = BFRot.Rotate(A - A0) + BF; //Vector3 AC = CFRot.Rotate(A - AF) + CF; //Vector3 Aend = AB * (1 - t) + AC * t; //float expectedSize = sizeB * (1 - t) + sizeC * t; //float size = Vector3.Magnitude(Aend - A); //resize[i] = size / expectedSize; } }
public NGonInterpolation(int sides) { this.sides = sides; this.cos_ = new float[sides]; this.sin_ = new float[sides]; //actually : angle dimension for the center piece float alpha = 2 * Mathf.PI / sides; //O, wow. what is dX2 = 1.5f? float dX2 = 1.5f; //Cos and sin of angle. Good float dx1 = (float)Mathf.Cos(alpha); float dy1 = (float)Mathf.Sin(alpha); //Need to understand the meaning of a and b this.a = 1.0f / (dX2 * dX2); this.b = ((1 - a * dx1 * dx1) / (dy1 * dy1)); //absolutely clear this is for (int i = 0; i < sides; i++) { cos_[i] = (float)Mathf.Cos(-alpha * i); sin_[i] = (float)Mathf.Sin(-alpha * i); } { //here we calculate the cornerCoordsMatrix, which is //the reciproc matrix to // | cos_[sides-1] - cos_[0] sin_[sides-1] - sin_[0]| // | cos_[1] - cos_[0] sin_[1] - sin_[0]| int i = 0; int next = 1; int prev = sides - 1; float a = cos_[prev] - cos_[i]; float b = sin_[prev] - sin_[i]; float c = cos_[next] - cos_[i]; float d = sin_[next] - sin_[i]; float det = a * d - b * c; float recDelta = 1.0f / det; cornerCoordsMatrix[0] = d * recDelta; cornerCoordsMatrix[1] = -b * recDelta; cornerCoordsMatrix[2] = -c * recDelta; cornerCoordsMatrix[3] = a * recDelta; //wait float length1 = (cornerCoordsMatrix[0] * cornerCoordsMatrix[0] + cornerCoordsMatrix[1] * cornerCoordsMatrix[1]); float length2 = (cornerCoordsMatrix[2] * cornerCoordsMatrix[2] + cornerCoordsMatrix[3] * cornerCoordsMatrix[3]); relativeTriangleFactorX = (cornerCoordsMatrix[0] * (-1)); relativeTriangleFactorY = (cornerCoordsMatrix[3] * (-1)); } this.val = new float[sides]; //cornerSurfacesSet.Init(sides); tmpInterpolations = new Vector3[sides]; tmpInterpolationsUV = new Vector3[sides]; buffers = new InterpolationBuffer[sides]; backBuffers = new InterpolationBuffer[sides]; for (int i = 0; i < tmpInterpolations.Length; i++) { buffers[i] = new InterpolationBuffer(); backBuffers[i] = new InterpolationBuffer(); } slicePosition = new int[sides]; }
private float GetBufferLength(InterpolationBuffer buffer) { return(Vector3.Distance(buffer.vertices[0], buffer.vertices[buffer.N])); }