public IOccluder Load(IArchiveDirectory occlusionDirectory)
{
bool isMainFigure = channelSystem.Parent == null;
if (isMainFigure)
{
IArchiveFile occluderParametersFile = occlusionDirectory.File("occluder-parameters.dat");
if (occluderParametersFile == null)
{
throw new InvalidOperationException("expected main figure to have occlusion system");
}
var occluderParameters = Persistance.Load <OccluderParameters>(occluderParametersFile);
OcclusionInfo[] unmorphedOcclusionInfos = OcclusionInfo.UnpackArray(unmorphedOcclusionDirectory.File("occlusion-infos.array").ReadArray <uint>());
var occluder = new DeformableOccluder(device, shaderCache, channelSystem, unmorphedOcclusionInfos, occluderParameters);
return(occluder);
}
else
{
OcclusionInfo[] figureOcclusionInfos = OcclusionInfo.UnpackArray(occlusionDirectory.File("occlusion-infos.array").ReadArray <uint>());
OcclusionInfo[] parentOcclusionInfos = OcclusionInfo.UnpackArray(occlusionDirectory.File("parent-occlusion-infos.array").ReadArray <uint>());
var occluder = new StaticOccluder(device, figureOcclusionInfos, parentOcclusionInfos);
return(occluder);
}
}
private void IncorporateChildOcclusionContributions(List <OcclusionInfo[]> childOcclusionContributions)
{
int count = unmorphedOcclusionInfos.Length;
OcclusionInfoBlender[] blenders = new OcclusionInfoBlender[count];
for (int i = 0; i < count; ++i)
{
blenders[i].Init(unmorphedOcclusionInfos[i]);
}
foreach (OcclusionInfo[] childOcclusionContribution in childOcclusionContributions)
{
if (childOcclusionContribution.Length != count)
{
throw new InvalidOperationException("parent-child occlusion info length mismatch");
}
for (int i = 0; i < count; ++i)
{
blenders[i].Add(childOcclusionContribution[i], unmorphedOcclusionInfos[i]);
}
}
OcclusionInfo[] results = new OcclusionInfo[count];
for (int i = 0; i < count; ++i)
{
results[i] = blenders[i].GetResult();
}
unmorphedWithChildrenOcclusionInfosToUpload = OcclusionInfo.PackArray(results);
}
public StaticOccluder(Device device, OcclusionInfo[] figureOcclusionInfos, OcclusionInfo[] parentOcclusionInfos)
{
this.device = device;
this.parentOcclusionInfos = parentOcclusionInfos;
occlusionInfosBufferManager = new StructuredBufferManager <uint>(device, figureOcclusionInfos.Length);
occlusionInfosToUpload = OcclusionInfo.PackArray(figureOcclusionInfos);
}
public void Add(OcclusionInfo occlusionInfo, OcclusionInfo baseOcclusionInfo)
{
if (frontRevealage != 0)
{
frontRevealage *= (1 - occlusionInfo.Front) / (1 - baseOcclusionInfo.Front);
}
if (backRevealage != 0)
{
backRevealage *= (1 - occlusionInfo.Back) / (1 - baseOcclusionInfo.Back);
}
}
private void DumpSimpleOcclusion(DirectoryInfo shapeDirectory, ChannelInputs shapeInputs, float[] faceTransparencies)
{
FileInfo occlusionInfosFile = shapeDirectory.File("occlusion-infos.array");
FileInfo parentOcclusionInfosFile = shapeDirectory.File("parent-occlusion-infos.array");
if (occlusionInfosFile.Exists)
{
return;
}
Console.WriteLine("Calculating occlusion...");
if (faceTransparencies == null)
{
faceTransparencies = FaceTransparencies.For(figure);
}
FigureGroup figureGroup;
FaceTransparenciesGroup faceTransparenciesGroup;
if (figure == parentFigure)
{
figureGroup = new FigureGroup(figure);
faceTransparenciesGroup = new FaceTransparenciesGroup(faceTransparencies);
}
else
{
var parentFaceTransparencies = FaceTransparencies.For(parentFigure);
figureGroup = new FigureGroup(parentFigure, figure);
faceTransparenciesGroup = new FaceTransparenciesGroup(parentFaceTransparencies, faceTransparencies);
}
var inputs = new ChannelInputsGroup(parentFigure.MakeDefaultChannelInputs(), new ChannelInputs[] { shapeInputs });
var outputs = figureGroup.Evaluate(inputs);
FigureOcclusionCalculator.Result occlusionResult;
using (var occlusionCalculator = new FigureOcclusionCalculator(fileLocator, device, shaderCache, figureGroup, faceTransparenciesGroup)) {
occlusionResult = occlusionCalculator.CalculateOcclusionInformation(outputs);
}
shapeDirectory.Create();
if (figure == parentFigure)
{
occlusionInfosFile.WriteArray(OcclusionInfo.PackArray(occlusionResult.ParentOcclusion));
}
else
{
occlusionInfosFile.WriteArray(OcclusionInfo.PackArray(occlusionResult.ChildOcclusions[0]));
parentOcclusionInfosFile.WriteArray(OcclusionInfo.PackArray(occlusionResult.ParentOcclusion));
}
}
public DeformableOccluder(Device device, ShaderCache shaderCache, ChannelSystem channelSystem, OcclusionInfo[] unmorphedOcclusionInfos, OccluderParameters parameters)
{
this.unmorphedOcclusionInfos = unmorphedOcclusionInfos;
shader = shaderCache.GetComputeShader <DeformableOccluder>("figure/occlusion/shader/Occluder");
unmorphedWithoutChildrenOcclusionInfosView = BufferUtilities.ToStructuredBufferView(device, OcclusionInfo.PackArray(unmorphedOcclusionInfos));
unmorphedWithChildrenOcclusionInfosBufferManager = new StructuredBufferManager <uint>(device, unmorphedOcclusionInfos.Length);
unmorphedWithChildrenOcclusionInfosToUpload = OcclusionInfo.PackArray(unmorphedOcclusionInfos);
parametersResources = OccluderParametersResources.Make(device, parameters);
channelIndices = parameters.ChannelNames
.Select(channelName => channelSystem.ChannelsByName[channelName].Index)
.ToArray();
}
public static OcclusionInfo[] UnpackArray(uint[] packedArray)
{
if (packedArray == null)
{
return(null);
}
int length = packedArray.Length;
OcclusionInfo[] array = new OcclusionInfo[length];
for (int i = 0; i < length; ++i)
{
array[i] = Unpack(packedArray[i]);
}
return(array);
}
public OccluderParameters CalculateOccluderParameters()
{
var baseInputs = MakePosedShapeInputs();
var baseOutputs = figure.Evaluate(null, baseInputs);
var baseOcclusionInfos = CalculateOcclusion(baseOutputs);
List <Channel> channels = new List <Channel>();
List <List <OcclusionDelta> > perVertexDeltas = new List <List <OcclusionDelta> >();
for (int i = 0; i < baseOcclusionInfos.Length; ++i)
{
perVertexDeltas.Add(new List <OcclusionDelta>());
}
foreach (var channel in GetChannelsForOcclusionSystem())
{
Console.WriteLine($"\t{channel.Name}...");
int occlusionChannelIdx = channels.Count;
channels.Add(channel);
var inputs = new ChannelInputs(baseInputs);
channel.SetValue(inputs, 1);
var outputs = figure.Evaluate(null, inputs);
var occlusionInfos = CalculateOcclusion(outputs);
for (int vertexIdx = 0; vertexIdx < occlusionInfos.Length; ++vertexIdx)
{
if (Math.Abs(occlusionInfos[vertexIdx].Front - baseOcclusionInfos[vertexIdx].Front) > OcclusionDifferenceThreshold)
{
var delta = new OcclusionDelta(occlusionChannelIdx, OcclusionInfo.Pack(occlusionInfos[vertexIdx]));
perVertexDeltas[vertexIdx].Add(delta);
}
}
}
var parameters = new OccluderParameters(
OcclusionInfo.PackArray(baseOcclusionInfos),
channels.Select(channel => channel.Name).ToList(),
PackedLists <OcclusionDelta> .Pack(perVertexDeltas));
return(parameters);
}
public static uint Pack(OcclusionInfo occlusionInfo)
{
return(IntegerUtils.Pack(
IntegerUtils.ToUShort(occlusionInfo.Front),
IntegerUtils.ToUShort(occlusionInfo.Back)));
}
public void Init(OcclusionInfo occlusionInfo)
{
frontRevealage = (1 - occlusionInfo.Front);
backRevealage = (1 - occlusionInfo.Back);
}
