public OccluderParametersCalculator(ContentFileLocator fileLocator, Device device, ShaderCache shaderCache, Figure figure, float[] faceTransparencies, ChannelInputs shapeInputs)
{
this.figure = figure;
this.shapeInputs = shapeInputs;
figureGroup = new FigureGroup(figure);
var faceTransparenciesGroup = new FaceTransparenciesGroup(faceTransparencies);
occlusionCalculator = new FigureOcclusionCalculator(fileLocator, device, shaderCache, figureGroup, faceTransparenciesGroup);
}
public Drawing(Canvas newParent)
{
if (Current == null)
{
Current = this;
}
Figures = new FigureGroup(this);
Parent = newParent;
Behavior = new Dragger();
}
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 FigureOcclusionCalculator(ContentFileLocator fileLocator, Device device, ShaderCache shaderCache, FigureGroup figureGroup, FaceTransparenciesGroup faceTransparenciesGroup)
{
this.device = device;
this.figureGroup = figureGroup;
var geometryConcatenator = new OcclusionGeometryConcatenator();
//parent
{
var figure = figureGroup.Parent;
var faceTransparencies = faceTransparenciesGroup.Parent;
var refinementResult = figure.Geometry.AsTopology().Refine(0);
var segment = geometryConcatenator.Add(refinementResult.Mesh, faceTransparencies);
parentSegment = segment;
var surrogates = figure.OcclusionBinding.Surrogates;
surrogateSegments = surrogates.Select(geometryConcatenator.Add).ToList();
}
//children
for (int childIdx = 0; childIdx < figureGroup.Children.Length; ++childIdx)
{
var figure = figureGroup.Children[childIdx];
var faceTransparencies = faceTransparenciesGroup.Children[childIdx];
var refinementResult = figure.Geometry.AsTopology().Refine(0);
var segment = geometryConcatenator.Add(refinementResult.Mesh, faceTransparencies);
childSegments.Add(segment);
var surrogates = figure.OcclusionBinding.Surrogates;
if (surrogates.Count != 0)
{
// There's no technical reason this couldn't be implemented; I just haven't needed it yet.
throw new NotImplementedException("occlusion surrogates aren't supported on child figures");
}
}
groupControlPositionsBufferManager = new StructuredBufferManager <Vector3>(device, geometryConcatenator.Mesh.ControlVertexCount);
vertexRefiner = new BasicVertexRefiner(device, shaderCache, geometryConcatenator.Mesh.Stencils);
refinedVertexInfosBufferManager = new InOutStructuredBufferManager <BasicRefinedVertexInfo>(device, vertexRefiner.RefinedVertexCount);
occlusionCalculator = new GpuOcclusionCalculator(device, shaderCache,
geometryConcatenator.Mesh.Topology,
geometryConcatenator.FaceTransparencies,
geometryConcatenator.FaceMasks,
geometryConcatenator.VertexMasks);
}
public Actor(Device device, List <Outfit> outfits, ActorModel model, FigureLoader figureLoader, FigureFacade mainFigure, FigureFacade hairFigure, ActorBehavior behavior)
{
this.outfits = outfits;
this.model = model;
this.figureLoader = figureLoader;
this.mainFigure = mainFigure;
this.hairFigure = hairFigure;
this.behavior = behavior;
clothingFigures = new FigureFacade[0];
mainFigure.Animator = new MainFigureAnimator(this);
figureGroup = new FigureGroup(device, mainFigure, new FigureFacade[0]);
SyncFigureGroup();
}
// ========================================
// constructor
// ========================================
public CompositeHandle(bool hideOnFocus) : base(hideOnFocus)
{
_composite = new CompositeSupport <IAuxiliaryHandle, CompositeHandle>(this);
_composite.DetailedPropertyChanged += (sender, e) => {
if (e.PropertyName == ICompositeProperty.Children)
{
OnChildrenChanged(e);
}
};
_figure = new FigureGroup();
_figure.VisibleChanged += (sender, e) => {
foreach (var child in Children)
{
child.Figure.IsVisible = _figure.IsVisible;
}
};
}
public static Figure FindExportTarget(FigureGroup group)
{
return(FindExportTarget(group.Parent, group.Children));
}
