public FigureGroup(Device device, FigureFacade parentFigure, FigureFacade[] childFigures)
{
this.parentFigure = parentFigure;
this.childFigures = childFigures;
this.modelToWorldTransform = new CoordinateNormalMatrixPairConstantBufferManager(device);
this.parentDeltas = new InOutStructuredBufferManager <Vector3>(device, parentFigure.VertexCount);
parentFigure.RegisterChildren(childFigures.ToList());
}
private OccluderParametersResources(Device device, OccluderParameters parameters)
{
vertexCount = parameters.BaseOcclusion.Length;
channelWeightsBufferManager = new StructuredBufferManager <float>(device, parameters.ChannelNames.Count);
baseOcclusionView = BufferUtilities.ToStructuredBufferView(device, parameters.BaseOcclusion);
occlusionDeltaWeightSegmentsView = BufferUtilities.ToStructuredBufferView(device, parameters.Deltas.Segments);
occlusionDeltaWeightElemsView = BufferUtilities.ToStructuredBufferView(device, parameters.Deltas.Elems);
calculatedInfosBuffersBufferManager = new InOutStructuredBufferManager <uint>(device, parameters.BaseOcclusion.Length);
}
public Scatterer(Device device, ShaderCache shaderCache, SubdivisionMesh mesh, PackedLists <Vector3WeightedIndex> formFactors)
{
vertexCount = mesh.Stencils.Count;
stencilSegments = BufferUtilities.ToStructuredBufferView(device, mesh.Stencils.Segments);
stencilElems = BufferUtilities.ToStructuredBufferView(device, mesh.Stencils.Elems);
formFactorSegments = BufferUtilities.ToStructuredBufferView(device, formFactors.Segments);
formFactorElements = BufferUtilities.ToStructuredBufferView(device, formFactors.Elems);
samplingShader = shaderCache.GetComputeShader <Scatterer>("figure/scattering/SampleVertexIrradiances");
scatteringShader = shaderCache.GetComputeShader <Scatterer>("figure/scattering/ScatterIrradiances");
sampledIrrandiancesBufferManager = new InOutStructuredBufferManager <Vector3>(device, vertexCount);
scatteredIrrandiancesBufferManager = new InOutStructuredBufferManager <Vector3>(device, vertexCount);
}
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 ControlVertexProvider(Device device, ShaderCache shaderCache,
OccluderLoader occluderLoader,
FigureDefinition definition,
ShaperParameters shaperParameters)
{
this.occluderLoader = occluderLoader;
this.definition = definition;
this.shaper = new GpuShaper(device, shaderCache, definition, shaperParameters);
this.vertexCount = shaperParameters.InitialPositions.Length;
controlVertexInfosBufferManager = new InOutStructuredBufferManager <ControlVertexInfo>(device, vertexCount);
if (definition.ChannelSystem.Parent == null)
{
this.controlVertexInfoStagingBufferManager = new StagingStructuredBufferManager <ControlVertexInfo>(device, vertexCount, BackingArrayCount);
}
}
private void ProcessTexturedSurface(int surfaceIdx, string uvSetName, FileInfo file, bool isLinear)
{
bool isOrderedTransparent = surfaceProperties.RenderOrder.Contains(surfaceIdx);
bool isMaxing = isOrderedTransparent;
var context = device.ImmediateContext;
var opacityTexture = LoadOpacityTexture(file, isLinear);
var opacityTextureView = new ShaderResourceView(device, opacityTexture);
// Not sure by, possibly a nvidia bug, but the vertex buffer padding by an extra element is necessary.
// Otherwise (0,0) gets passed to the vertex shader instead of the last vertex.
var uvSet = figure.UvSets[uvSetName];
var vertices = uvSet.Uvs;
var vertexBufferSizeInBytes = Vector2.SizeInBytes * (vertices.Length + 1);
var vertexBuffer = Buffer.Create(device, BindFlags.VertexBuffer, vertices, vertexBufferSizeInBytes);
List <int> faceIdxMap = new List <int>();
List <int> triangleIndices = new List <int>();
for (int faceIdx = 0; faceIdx < faceCount; ++faceIdx)
{
if (figure.Geometry.SurfaceMap[faceIdx] != surfaceIdx)
{
continue;
}
faceIdxMap.Add(faceIdx);
Quad face = figure.DefaultUvSet.Faces[faceIdx];
triangleIndices.Add(face.Index0);
triangleIndices.Add(face.Index1);
triangleIndices.Add(face.Index2);
if (!face.IsDegeneratedIntoTriangle)
{
triangleIndices.Add(face.Index2);
triangleIndices.Add(face.Index3);
triangleIndices.Add(face.Index0);
}
}
var indexBuffer = Buffer.Create(device, BindFlags.IndexBuffer, triangleIndices.ToArray());
var transparencyCounterBufferManager = new InOutStructuredBufferManager <TransparencyCounters>(device, faceIdxMap.Count);
context.ClearState();
states.Apply(context);
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.InputLayout = inputLayout;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBuffer, Vector2.SizeInBytes, 0));
context.InputAssembler.SetIndexBuffer(indexBuffer, Format.R32_UInt, 0);
context.VertexShader.Set(vertexShader);
context.Rasterizer.SetViewport(0, 0, opacityTexture.Description.Width, opacityTexture.Description.Height);
context.PixelShader.Set(isMaxing ? maxingPixelShader : addingPixelShader);
context.PixelShader.SetShaderResources(0, opacityTextureView);
context.OutputMerger.SetUnorderedAccessView(0, transparencyCounterBufferManager.OutView);
context.DrawIndexed(triangleIndices.Count, 0, 0);
context.ClearState();
var transparencyCounterStagingBufferManager = new StagingStructuredBufferManager <TransparencyCounters>(device, faceIdxMap.Count);
transparencyCounterStagingBufferManager.CopyToStagingBuffer(context, transparencyCounterBufferManager.Buffer);
var array = transparencyCounterStagingBufferManager.FillArrayFromStagingBuffer(context);
for (int faceIdx = 0; faceIdx < faceIdxMap.Count; ++faceIdx)
{
TransparencyCounters transparencyCounter = array[faceIdx];
if (transparencyCounter.pixelCount > (1 << 24))
{
throw new Exception("pixel count overflow");
}
float transparency;
if (isMaxing)
{
transparency = (float)transparencyCounter.transparencyCount / 0xff;
}
else
{
transparency = transparencyCounter.transparencyCount == 0 ? 0 : (float)transparencyCounter.transparencyCount / transparencyCounter.pixelCount / 0xff;
}
faceTransparencies[faceIdxMap[faceIdx]] = transparency;
}
opacityTextureView.Dispose();
opacityTexture.Dispose();
indexBuffer.Dispose();
vertexBuffer.Dispose();
transparencyCounterBufferManager.Dispose();
transparencyCounterStagingBufferManager.Dispose();
}
