public void Run()
{
int controlVertexCount = 6;
Quad[] controlFaces = new [] {
new Quad(0, 1, 2, 3),
new Quad(1, 4, 5, 2)
};
QuadTopology controlTopology = new QuadTopology(controlVertexCount, controlFaces);
int refinementLevel = 1;
using (Refinement refinement = new Refinement(controlTopology, refinementLevel)) {
QuadTopology topology = refinement.GetTopology();
int[] faceMap = refinement.GetFaceMap();
for (int faceIdx = 0; faceIdx < topology.Faces.Length; ++faceIdx)
{
Console.WriteLine(topology.Faces[faceIdx] + " -> " + faceMap[faceIdx]);
}
Console.WriteLine();
PackedLists <WeightedIndex> stencils = refinement.GetStencils(StencilKind.LimitStencils);
Console.WriteLine("stencils: ");
for (int vertexIdx = 0; vertexIdx < stencils.Count; ++vertexIdx)
{
Console.WriteLine(vertexIdx + ":");
foreach (WeightedIndex weightedIndex in stencils.GetElements(vertexIdx))
{
Console.WriteLine("\t" + weightedIndex.Index + " -> " + weightedIndex.Weight);
}
}
}
}
public T[] Refine <T, U>(T[] controlVectors, U operators) where U : IVectorOperators <T>
{
T[] refinedVertices = new T[stencils.Count];
for (int i = 0; i < stencils.Count; ++i)
{
T refinedVertex = operators.Zero();
foreach (var weightedIndex in stencils.GetElements(i))
{
refinedVertex = operators.Add(refinedVertex, operators.Mul(weightedIndex.Weight, controlVectors[weightedIndex.Index]));
}
refinedVertices[i] = refinedVertex;
}
return(refinedVertices);
}
public void Apply(Vector3[] baseDeltas, Vector3[] controlPositions)
{
for (int childVertexIdx = 0; childVertexIdx < controlPositions.Length; ++childVertexIdx)
{
Vector3 delta = Vector3.Zero;
foreach (var baseDeltaWeight in baseDeltaWeights.GetElements(childVertexIdx))
{
delta += baseDeltaWeight.Weight * baseDeltas[baseDeltaWeight.Index];
}
controlPositions[childVertexIdx] += delta;
}
}
public void Apply(StagedSkinningTransform[] allBoneTransforms, Vector3[] vertices)
{
var boneTransforms = bones.Select(bone => allBoneTransforms[bone.Index]).ToArray();
for (int i = 0; i < boneWeights.Count; ++i)
{
StagedSkinningTransformBlender blender = new StagedSkinningTransformBlender();
foreach (var boneWeight in boneWeights.GetElements(i))
{
blender.Add(boneWeight.Weight, boneTransforms[boneWeight.Index]);
}
Vector3 vertex = vertices[i];
vertex = blender.GetResult().Transform(vertex);
vertices[i] = vertex;
}
}
public static PackedLists <Vector3WeightedIndex> Merge(
PackedLists <WeightedIndex> values0,
PackedLists <WeightedIndex> values1,
PackedLists <WeightedIndex> values2)
{
int segmentCount = values0.Count;
if (values1.Count != segmentCount)
{
throw new InvalidOperationException("expected values1 count to match");
}
if (values2.Count != segmentCount)
{
throw new InvalidOperationException("expected values2 count to match");
}
var combined = new List <List <Vector3WeightedIndex> >(segmentCount);
for (int segmentIdx = 0; segmentIdx < segmentCount; ++segmentIdx)
{
IEnumerable <Vector3WeightedIndex> v0s = values0.GetElements(segmentIdx)
.Select(w => new Vector3WeightedIndex(w.Index, new Vector3(w.Weight, 0, 0)));
IEnumerable <Vector3WeightedIndex> v1s = values1.GetElements(segmentIdx)
.Select(w => new Vector3WeightedIndex(w.Index, new Vector3(0, w.Weight, 0)));
IEnumerable <Vector3WeightedIndex> v2s = values2.GetElements(segmentIdx)
.Select(w => new Vector3WeightedIndex(w.Index, new Vector3(0, 0, w.Weight)));
List <Vector3WeightedIndex> combinedWeightedIndices = v0s.Concat(v1s).Concat(v2s).GroupBy(w => w.Index).Select(group => {
float sum0 = group.Sum(w => w.Weight[0]);
float sum1 = group.Sum(w => w.Weight[1]);
float sum2 = group.Sum(w => w.Weight[2]);
return(new Vector3WeightedIndex(group.Key, new Vector3(sum0, sum1, sum2)));
}).ToList();
combined.Add(combinedWeightedIndices);
}
return(PackedLists <Vector3WeightedIndex> .Pack(combined));
}
public static PackedLists <WeightedIndexWithDerivatives> Merge(
PackedLists <WeightedIndex> valueStencils,
PackedLists <WeightedIndex> duStencils,
PackedLists <WeightedIndex> dvStencils)
{
int segmentCount = valueStencils.Count;
if (duStencils.Count != segmentCount)
{
throw new InvalidOperationException("expected du segment count to match");
}
if (dvStencils.Count != segmentCount)
{
throw new InvalidOperationException("expected dv segment count to match");
}
var combinedStencils = new List <List <WeightedIndexWithDerivatives> >(segmentCount);
for (int segmentIdx = 0; segmentIdx < segmentCount; ++segmentIdx)
{
IEnumerable <WeightedIndexWithDerivatives> values = valueStencils.GetElements(segmentIdx)
.Select(w => new WeightedIndexWithDerivatives(w.Index, w.Weight, 0, 0));
IEnumerable <WeightedIndexWithDerivatives> dvs = duStencils.GetElements(segmentIdx)
.Select(w => new WeightedIndexWithDerivatives(w.Index, 0, w.Weight, 0));
IEnumerable <WeightedIndexWithDerivatives> dus = dvStencils.GetElements(segmentIdx)
.Select(w => new WeightedIndexWithDerivatives(w.Index, 0, 0, w.Weight));
List <WeightedIndexWithDerivatives> combinedWeightedIndices = values.Concat(dvs).Concat(dus).GroupBy(w => w.Index).Select(group => {
float sumWeight = group.Sum(w => w.Weight);
float sumDuWeight = group.Sum(w => w.DuWeight);
float sumDvWeight = group.Sum(w => w.DvWeight);
return(new WeightedIndexWithDerivatives(group.Key, sumWeight, sumDuWeight, sumDvWeight));
}).ToList();
combinedStencils.Add(combinedWeightedIndices);
}
return(PackedLists <WeightedIndexWithDerivatives> .Pack(combinedStencils));
}
