private void SortByProximityToCamera(ModelInstanceManager.MIDArray midArray)
{
if (localMidComparer == null)
{
localMidComparer = new MIDComparer();
}
if (sortedModelData == null || sortedModelData.Length < midArray.Length)
{
sortedModelData = new ModelInstanceData[midArray.Length << 1];
}
for (int i = 0; i < midArray.Length; ++i)
{
sortedModelData[i] = midArray.Data[i];
}
localMidComparer.CamPos = Input.Position;
Array.Sort(sortedModelData, 0, (int)midArray.Length, localMidComparer);
}
private void RenderCache_IterateMaterial(int materialIndex)
{
// Set up context variables
KeyValuePair <Material, ModelInstanceManager.MIDArray> currentKVP = currentInstanceData[materialIndex];
Material currentMaterial = currentKVP.Key;
ModelInstanceManager.MIDArray currentMID = currentKVP.Value;
// Skip this material if it or its shader are disposed
if (currentMaterial.IsDisposed || currentMaterial.Shader.IsDisposed)
{
return;
}
// Prepare shader according to material params, and switch to it or update it
if (lastSetFragmentShader != currentMaterial.Shader || lastFrameNum != frameNum)
{
lastSetFragmentShader = currentMaterial.Shader;
lastFrameNum = frameNum;
QueueShaderSwitch(lastSetFragmentShader);
}
QueueShaderResourceUpdate(lastSetFragmentShader, currentMaterial.FragmentShaderResourcePackage);
// Filter & sort
if (materialFilteringWorkspace == null || materialFilteringWorkspace.Length < currentCache.NumModels)
{
materialFilteringWorkspace = new FastClearList <Transform> [currentCache.NumModels];
for (int i = 0; i < materialFilteringWorkspace.Length; ++i)
{
materialFilteringWorkspace[i] = new FastClearList <Transform>();
}
}
for (int i = 0; i < materialFilteringWorkspace.Length; ++i)
{
materialFilteringWorkspace[i].Clear();
}
ModelInstanceData *midData = currentMID.Data;
uint numInstances = 0U;
for (uint i = 0U; i < currentMID.Length; ++i)
{
ModelInstanceData curMID = midData[i];
if (!curMID.InUse)
{
continue;
}
SceneLayer layer = currentSceneLayers[curMID.SceneLayerIndex];
if (layer == null || !layer.GetRenderingEnabled() || !addedSceneLayers.Contains(layer))
{
continue;
}
materialFilteringWorkspace[curMID.ModelIndex].Add(curMID.Transform);
++numInstances;
}
// Concatenate & queue render commands
if (instanceConcatWorkspace == null || instanceConcatWorkspace.Length < numInstances)
{
instanceConcatWorkspace = new Matrix[numInstances << 1]; // x2 so we don't create loads of garbage if the count keeps increasing by 1
}
uint instanceStartOffset = RenderCache_IterateMaterial_ConcatReserve(numInstances);
uint nextWorkspaceIndex = 0;
uint outVBStartIndex, outIBStartIndex, outVBCount, outIBCount;
for (uint mI = 0U; mI < materialFilteringWorkspace.Length; ++mI)
{
FastClearList <Transform> filteredTransformList = materialFilteringWorkspace[mI];
int numFilteredTransforms = filteredTransformList.Count;
if (numFilteredTransforms == 0)
{
continue;
}
currentCache.GetModelBufferValues(mI, out outVBStartIndex, out outIBStartIndex, out outVBCount, out outIBCount);
QueueRenderCommand(RenderCommand.DrawIndexedInstanced(
(int)outVBStartIndex,
outIBStartIndex,
outIBCount,
nextWorkspaceIndex + instanceStartOffset,
(uint)numFilteredTransforms
));
for (int iI = 0; iI < numFilteredTransforms; ++iI)
{
instanceConcatWorkspace[nextWorkspaceIndex++] = filteredTransformList[iI].AsMatrixTransposed;
}
}
RenderCache_IterateMaterial_Concat(instanceConcatWorkspace, instanceStartOffset, numInstances);
}
private void RenderCache_IterateMaterial(int materialIndex)
{
// Set up context variables
KeyValuePair <Material, ModelInstanceManager.MIDArray> currentKVP = currentInstanceData[materialIndex];
Material currentMaterial = currentKVP.Key;
ModelInstanceManager.MIDArray currentMID = currentKVP.Value;
// Skip this material if it or its shader are disposed
if (currentMaterial.IsDisposed || currentMaterial.Shader.IsDisposed)
{
return;
}
// Skip this material if we're not using it
bool inUse = false;
for (int i = 0; i < currentMID.Length; ++i)
{
if (currentMID.Data[i].InUse)
{
inUse = true;
break;
}
}
if (!inUse)
{
return;
}
// Prepare shader according to material params, and switch to it or update it
if (lastSetFragmentShader != currentMaterial.Shader || lastFrameNum != frameNum)
{
lastSetFragmentShader = currentMaterial.Shader;
lastFrameNum = frameNum;
QueueShaderSwitch(lastSetFragmentShader);
}
var queuedSRP = currentMaterial.FragmentShaderResourcePackage;
if (lastSetFragmentShader == geomFSWithShadowSupport)
{
if (modifiedSRP == null)
{
modifiedSRP = new ShaderResourcePackage();
}
modifiedSRP.CopyFrom(queuedSRP);
modifiedSRP.SetValue((ResourceViewBinding)lastSetFragmentShader.GetBindingByIdentifier("ShadowMap"), previousShadowBufferSRV);
queuedSRP = modifiedSRP;
}
QueueShaderResourceUpdate(lastSetFragmentShader, queuedSRP);
// Filter & sort
if (materialFilteringWorkspace == null || materialFilteringWorkspace.Length < currentCache.NumModels)
{
materialFilteringWorkspace = new FastClearList <Transform> [currentCache.NumModels];
for (int i = 0; i < materialFilteringWorkspace.Length; ++i)
{
materialFilteringWorkspace[i] = new FastClearList <Transform>();
}
}
for (int i = 0; i < materialFilteringWorkspace.Length; ++i)
{
materialFilteringWorkspace[i].Clear();
}
SortByProximityToCamera(currentMID);
uint numInstances = 0U;
for (uint i = 0U; i < currentMID.Length; ++i)
{
ModelInstanceData curMID = sortedModelData[i];
if (!curMID.InUse)
{
continue;
}
SceneLayer layer = currentSceneLayers[curMID.SceneLayerIndex];
if (layer == null || !layer.GetRenderingEnabled() || !addedSceneLayers.Contains(layer))
{
continue;
}
if (curMID.ModelIndex == __VEGG_MH.ModelIndex && currentCache.ID == __VEGG_MH.GeoCacheID)
{
int instanceIndex = 0;
for (int j = 0; j < currentMID.Length; ++j)
{
if (currentMID.Data[j].Transform == curMID.Transform)
{
instanceIndex = j;
break;
}
}
Quaternion rot = Quaternion.IDENTITY;
foreach (var kvp in __VEGG_MIH_ARR)
{
if (kvp.Key.InstanceIndex == instanceIndex)
{
rot = kvp.Value;
break;
}
}
materialFilteringWorkspace[curMID.ModelIndex].Add(curMID.Transform.RotateBy(rot));
}
else
{
materialFilteringWorkspace[curMID.ModelIndex].Add(curMID.Transform);
}
++numInstances;
}
// Concatenate & queue render commands
if (instanceConcatWorkspace == null || instanceConcatWorkspace.Length < numInstances)
{
instanceConcatWorkspace = new Matrix[numInstances << 1]; // x2 so we don't create loads of garbage if the count keeps increasing by 1
}
uint instanceStartOffset = RenderCache_IterateMaterial_ConcatReserve(numInstances);
uint nextWorkspaceIndex = 0;
uint outVBStartIndex, outIBStartIndex, outVBCount, outIBCount;
for (uint mI = 0U; mI < materialFilteringWorkspace.Length; ++mI)
{
FastClearList <Transform> filteredTransformList = materialFilteringWorkspace[mI];
int numFilteredTransforms = filteredTransformList.Count;
if (numFilteredTransforms == 0)
{
continue;
}
currentCache.GetModelBufferValues(mI, out outVBStartIndex, out outIBStartIndex, out outVBCount, out outIBCount);
QueueRenderCommand(RenderCommand.DrawIndexedInstanced(
(int)outVBStartIndex,
outIBStartIndex,
outIBCount,
nextWorkspaceIndex + instanceStartOffset,
(uint)numFilteredTransforms
));
for (int iI = 0; iI < numFilteredTransforms; ++iI)
{
if (mI == __EGGHACK_MH.ModelIndex && currentCache.ID == __EGGHACK_MH.GeoCacheID)
{
instanceConcatWorkspace[nextWorkspaceIndex++] = filteredTransformList[iI].RotateBy(__EGGHACK_ROT).AsMatrixTransposed;
}
else
{
instanceConcatWorkspace[nextWorkspaceIndex++] = filteredTransformList[iI].AsMatrixTransposed;
}
}
}
RenderCache_IterateMaterial_Concat(instanceConcatWorkspace, instanceStartOffset, numInstances);
}
public unsafe void TestCreateAndDestroyInstance()
{
// Define variables and constants
const int NUM_INSTANCES = 1000;
var gcb = new GeometryCacheBuilder <TestVertex>();
gcb.AddModel("TCADI_a", new[] { new TestVertex(Vector3.ONE), new TestVertex(Vector3.LEFT), }, new[] { 0U, 1U, 1U, 0U, 1U, 0U });
gcb.AddModel("TCADI_b", new[] { new TestVertex(Vector3.RIGHT), new TestVertex(Vector3.UP), }, new[] { 0U, 1U, 1U, 0U, 1U, 0U });
gcb.AddModel("TCADI_c", new[] { new TestVertex(Vector3.ZERO), new TestVertex(Vector3.DOWN), }, new[] { 0U, 1U, 1U, 0U, 1U, 0U });
GeometryCache testCache = gcb.Build();
SceneLayer testLayerA = Scene.CreateLayer("Test Layer A");
SceneLayer testLayerB = Scene.CreateLayer("Test Layer B");
ConstantBuffer <Vector4> fsColorBuffer = BufferFactory.NewConstantBuffer <Vector4>().WithUsage(ResourceUsage.DiscardWrite);
FragmentShader fs = new FragmentShader(@"Tests\SimpleFS.cso", new ConstantBufferBinding(0U, "MaterialProperties", fsColorBuffer));
Material testMatA = new Material("Brick", fs);
Material testMatB = new Material("Wood", fs);
// Set up context
// Execute
ModelInstanceHandle[] instanceArr = new ModelInstanceHandle[NUM_INSTANCES];
for (int i = 0; i < NUM_INSTANCES; ++i)
{
Transform transform = new Transform(
Vector3.ONE * i,
Quaternion.FromAxialRotation(Vector3.UP, i),
Vector3.ONE * -i
);
if (i % 5 == 0)
{
instanceArr[i] = testLayerA.CreateModelInstance(new ModelHandle(testCache.ID, (uint)(i % 3)), (i % 2 == 0 ? testMatA : testMatB), transform);
}
else
{
instanceArr[i] = testLayerB.CreateModelInstance(new ModelHandle(testCache.ID, (uint)(i % 3)), (i % 2 == 0 ? testMatA : testMatB), transform);
}
}
// Assert outcome
RenderingModule.RenderStateBarrier.FreezeMutations(); // Cheeky, but we have to on debug mode (and it's re-entrant for now, so no problem)
var instanceData = testCache.GetModelInstanceData();
for (int i = 0; i < NUM_INSTANCES; ++i)
{
Material instanceMaterial = Material.GetMaterialByIndex(instanceArr[i].MaterialIndex);
ModelInstanceManager.MIDArray materialDataArray = instanceData.First(kvp => kvp.Key == instanceMaterial).Value;
Assert.AreEqual((i % 2 == 0 ? testMatA : testMatB), instanceMaterial);
Assert.AreEqual((i % 5 == 0 ? testLayerA : testLayerB), Scene.GetLayerByIndex(materialDataArray.Data[GetMIHInstanceIndex(instanceArr[i])].SceneLayerIndex));
Assert.IsTrue(materialDataArray.Data[GetMIHInstanceIndex(instanceArr[i])].InUse);
Assert.AreEqual((uint)(i % 3), materialDataArray.Data[GetMIHInstanceIndex(instanceArr[i])].ModelIndex);
Assert.AreEqual(
new Transform(
Vector3.ONE * i,
Quaternion.FromAxialRotation(Vector3.UP, i),
Vector3.ONE * -i
),
instanceArr[i].Transform
);
Assert.AreEqual(instanceArr[i].Transform, materialDataArray.Data[GetMIHInstanceIndex(instanceArr[i])].Transform);
instanceArr[i].Dispose();
Assert.IsFalse(materialDataArray.Data[GetMIHInstanceIndex(instanceArr[i])].InUse);
}
RenderingModule.RenderStateBarrier.UnfreezeMutations();
testCache.Dispose();
testMatA.Dispose();
testMatB.Dispose();
testLayerA.Dispose();
testLayerB.Dispose();
fs.Dispose();
fsColorBuffer.Dispose();
}