internal void PSBindRawSRV(int slot, IShaderResourceBindable srv)
{
DeviceContext.PixelShader.SetShaderResources(0, srv.SRV);
Stats.BindShaderResources++;
MyRender11.ProcessDebugOutput();
}
internal void BindUAV(int slot, MyBindableResource UAV, int initialCount = -1)
{
if (UAV != null)
{
var ua = UAV as IUnorderedAccessBindable;
Debug.Assert(ua != null);
UnbindSRVRead(UAV.GetID());
//UnbindDSVReadOnly(UAVs[i].ResId); necessary?
List <int> keyList = State.m_slotToBindingKeys.GetList(slot);
if (keyList != null)
{
keyList.Sort(KeyListComparer.Comparer);
State.m_bindings.Remove(keyList[0]);
State.m_slotToBindingKeys.Remove(slot);
}
var binding = new MyBinding(MyWriteBindingEnum.UAV, slot);
State.m_bindings[UAV.GetID()] = binding;
State.m_slotToBindingKeys.Add(slot, UAV.GetID());
ComputeShaderId.TmpUav[0] = ua.UAV;
}
ComputeShaderId.TmpCount[0] = initialCount;
DeviceContext.ComputeShader.SetUnorderedAccessViews(slot, ComputeShaderId.TmpUav, ComputeShaderId.TmpCount);
ComputeShaderId.TmpCount[0] = -1;
MyRender11.ProcessDebugOutput();
}
internal void SetVBs(Buffer[] vbs, int[] strides)
{
if (vbs != null && strides != null)
{
bool change = false;
bool lastSlot = false;
for (int i = 0; i < vbs.Length; i++)
{
if (vbs[i] != null)
{
lastSlot = change == false && i == (vbs.Length - 1);
change = UpdateVB(i, vbs[i], strides[i]) || change;
}
}
if (lastSlot)
{
int slot = vbs.Length - 1;
DeviceContext.InputAssembler.SetVertexBuffers(slot, new VertexBufferBinding(State.m_VBs[slot], State.m_strides[slot], 0));
Stats.SetVB++;
}
else if (change)
{
DeviceContext.InputAssembler.SetVertexBuffers(0, State.m_VBs, State.m_strides, ZeroOffsets);
Stats.SetVB++;
}
MyRender11.ProcessDebugOutput();
}
}
internal void CSBindRawSRV(int slot, ShaderResourceView srv)
{
DeviceContext.ComputeShader.SetShaderResource(slot, srv);
Stats.BindShaderResources++;
MyRender11.ProcessDebugOutput();
}
internal void PSBindRawSRV(int slot, ShaderResourceView[] srvs)
{
DeviceContext.PixelShader.SetShaderResources(0, srvs);
Stats.BindShaderResources++;
MyRender11.ProcessDebugOutput();
}
private static void Render(ISrvBindable textureArraySRV, ISrvBindable depthRead)
{
RC.VertexShader.Set(m_vs);
if (MyRender11.Settings.DisplayTransparencyHeatMap)
{
if (MyRender11.DebugOverrides.OIT)
{
RC.PixelShader.Set(m_psDebugUniformAccumOIT);
}
else
{
RC.PixelShader.Set(m_psDebugUniformAccum);
}
}
else
{
if (MyRender11.DebugOverrides.OIT)
{
RC.PixelShader.Set(m_psOIT);
}
else
{
RC.PixelShader.Set(m_ps);
}
}
RC.SetVertexBuffer(0, null);
RC.SetIndexBuffer(m_ib);
RC.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
RC.AllShaderStages.SetConstantBuffer(1, m_activeListConstantBuffer);
RC.AllShaderStages.SetSrv(0, depthRead);
RC.PixelShader.SetSrvs(1, textureArraySRV);
RC.VertexShader.SetSrv(0, m_particleBuffer);
RC.VertexShader.SetSrv(1, m_emitterStructuredBuffer);
RC.VertexShader.SetSrv(2, m_aliveIndexBuffer);
ISrvBindable skybox = MyRender11.IsIntelBrokenCubemapsWorkaround
? MyGeneratedTextureManager.IntelFallbackCubeTex
: (ISrvBindable)MyManagers.EnvironmentProbe.Cubemap;
RC.VertexShader.SetSrv(MyCommon.SKYBOX_IBL_SLOT, skybox);
// bind render target?
if (!MyStereoRender.Enable)
{
RC.DrawIndexedInstancedIndirect(m_indirectDrawArgsBuffer, 0);
}
else
{
MyStereoRender.DrawIndexedInstancedIndirectGPUParticles(RC, m_indirectDrawArgsBuffer, 0);
}
MyRender11.ProcessDebugOutput();
RC.VertexShader.SetSrv(MyCommon.SKYBOX_IBL_SLOT, null);
RC.AllShaderStages.SetSrv(0, null);
}
internal void SetVB(int slot, Buffer vb, int stride)
{
if (UpdateVB(slot, vb, stride))
{
DeviceContext.InputAssembler.SetVertexBuffers(slot, new VertexBufferBinding(vb, stride, 0));
Stats.SetVB++;
MyRender11.ProcessDebugOutput();
}
}
internal void PSBindRawSRV(int slot, IShaderResourceBindable srv)
{
ShaderResourceView sharpSRV = srv != null ? srv.SRV : null;
DeviceContext.PixelShader.SetShaderResources(slot, sharpSRV);
Stats.BindShaderResources++;
MyRender11.ProcessDebugOutput();
}
internal void Finish()
{
if (!m_finished && m_deferred)
{
m_finished = true;
m_commandList = DeviceContext.FinishCommandList(false);
MyRender11.ProcessDebugOutput();
}
}
internal void BindRawSRV(int slot, ShaderResourceView srv)
{
DeviceContext.VertexShader.SetShaderResource(slot, srv);
DeviceContext.PixelShader.SetShaderResource(slot, srv);
Stats.BindShaderResources++;
Stats.BindShaderResources++;
MyRender11.ProcessDebugOutput();
}
internal void SetBS(BlendState bs, Color4?blendFactor = null)
{
if (State.m_BS != bs || blendFactor != null)
{
State.m_BS = bs;
DeviceContext.OutputMerger.SetBlendState(bs, blendFactor);
Stats.SetBlendState++;
MyRender11.ProcessDebugOutput();
}
}
internal void SetRS(RasterizerState rs)
{
if (State.m_RS != rs)
{
State.m_RS = rs;
DeviceContext.Rasterizer.State = rs;
Stats.SetRasterizerState++;
MyRender11.ProcessDebugOutput();
}
}
internal void SetIL(InputLayout il)
{
if (State.m_inputLayout != il)
{
State.m_inputLayout = il;
DeviceContext.InputAssembler.InputLayout = il;
Stats.SetIL++;
MyRender11.ProcessDebugOutput();
}
}
internal void SetDS(DepthStencilState ds, int stencilRef = 0)
{
if ((State.m_DS != ds) || (State.m_stencilRef != stencilRef))
{
State.m_DS = ds;
State.m_stencilRef = stencilRef;
DeviceContext.OutputMerger.SetDepthStencilState(ds, stencilRef);
MyRender11.ProcessDebugOutput();
}
}
internal void SetVS(VertexShader vs)
{
if (State.m_vs != vs)
{
State.m_vs = vs;
DeviceContext.VertexShader.Set(vs);
Stats.SetVS++;
MyRender11.ProcessDebugOutput();
}
}
internal void SetGS(GeometryShader gs)
{
if (State.m_gs != gs)
{
State.m_gs = gs;
DeviceContext.GeometryShader.Set(gs);
Stats.SetGS++;
MyRender11.ProcessDebugOutput();
}
}
internal void SetPS(PixelShader ps)
{
if (State.m_ps != ps)
{
State.m_ps = ps;
DeviceContext.PixelShader.Set(ps);
Stats.SetPS++;
MyRender11.ProcessDebugOutput();
}
}
internal void SetIB(Buffer ib, Format format)
{
if (State.m_IB != ib)
{
State.m_IB = ib;
DeviceContext.InputAssembler.SetIndexBuffer(ib, format, 0);
Stats.SetIB++;
MyRender11.ProcessDebugOutput();
}
}
internal void SetSRVs(ref MySrvTable desc)
{
//if (desc.BindFlag.HasFlag(MyBindFlag.BIND_VS))
//{
// var val = new MyStageSrvBinding { Stage = MyShaderStage.VS, Slot = desc.StartSlot, Length = desc.SRVs.Length, Version = desc.Version };
// int f = State.m_srvBindings1.BinarySearch(val);
// var index = ~f;
// bool match = f >= 0; // if yes no need to bind
// bool collision = (index < State.m_srvBindings1.Count) &&
// State.m_srvBindings1[index].Stage == val.Stage &&
// (val.Slot + val.Length) >= State.m_srvBindings1[index].Slot; // if yes replace, if no add before, bind anyway
// if(!match && collision)
// {
// State.m_srvBindings1[index] = val;
// Context.VertexShader.SetShaderResources(desc.StartSlot, desc.SRVs);
// }
// else if(!match && !collision)
// {
// State.m_srvBindings1.Insert(index, val);
// Context.VertexShader.SetShaderResources(desc.StartSlot, desc.SRVs);
// }
//}
if ((desc.BindFlag & MyBindFlag.BIND_VS) > 0 &&
State.m_srvTableBindings.Get(new MyStageSrvBinding {
Stage = MyShaderStage.VS, Slot = desc.StartSlot
}, NO_VERSION) != desc.Version)
{
State.m_srvTableBindings[new MyStageSrvBinding {
Stage = MyShaderStage.VS, Slot = desc.StartSlot
}] = desc.Version;
for (int i = 0; i < desc.SRVs.Length; i++)
{
DeviceContext.VertexShader.SetShaderResource(desc.StartSlot + i, desc.SRVs[i].SRV);
}
}
if ((desc.BindFlag & MyBindFlag.BIND_PS) > 0 &&
State.m_srvTableBindings.Get(new MyStageSrvBinding {
Stage = MyShaderStage.PS, Slot = desc.StartSlot
}, NO_VERSION) != desc.Version)
{
State.m_srvTableBindings[new MyStageSrvBinding {
Stage = MyShaderStage.PS, Slot = desc.StartSlot
}] = desc.Version;
for (int i = 0; i < desc.SRVs.Length; i++)
{
DeviceContext.PixelShader.SetShaderResource(desc.StartSlot + i, desc.SRVs[i].SRV);
}
}
MyRender11.ProcessDebugOutput();
}
public static void SetConstants(MyRenderContext rc, ref MyConstantsPack desc, int slot)
{
if ((desc.BindFlag & MyBindFlag.BIND_VS) > 0)
{
rc.VertexShader.SetConstantBuffer(slot, desc.CB);
}
if ((desc.BindFlag & MyBindFlag.BIND_PS) > 0)
{
rc.PixelShader.SetConstantBuffer(slot, desc.CB);
}
MyRender11.ProcessDebugOutput();
}
internal static void InitBlendState(BlendId id)
{
try
{
BlendObjects[id.Index] = new BlendState(MyRender11.Device, BlendStates.Data[id.Index]);
}
catch
{
MyRender11.ProcessDebugOutput();
throw;
}
}
internal void SetCB(int slot, Buffer cb)
{
if (State.m_CBs[slot] != cb)
{
State.m_CBs[slot] = cb;
DeviceContext.VertexShader.SetConstantBuffer(slot, cb);
Stats.SetCB++;
DeviceContext.GeometryShader.SetConstantBuffer(slot, cb);
Stats.SetCB++;
DeviceContext.PixelShader.SetConstantBuffer(slot, cb);
Stats.SetCB++;
MyRender11.ProcessDebugOutput();
}
}
internal unsafe void MoveConstants(ref MyConstantsPack desc)
{
if (desc.CB == null)
{
return;
}
if (State.m_constantsVersion.Get(desc.CB) != desc.Version)
{
State.m_constantsVersion[desc.CB] = desc.Version;
var mapping = MyMapping.MapDiscard(DeviceContext, desc.CB);
mapping.WriteAndPosition(desc.Data, 0, desc.Data.Length);
mapping.Unmap();
}
MyRender11.ProcessDebugOutput();
}
public void Draw(bool draw = true)
{
#if DEBUG
try
{
MyRender11.Draw(draw);
}
catch (Exception ex)
{
MyRender11.ProcessDebugOutput();
System.Diagnostics.Debug.WriteLine(ex);
}
#else
MyRender11.Draw(draw);
#endif
}
internal static void SetSrvs(MyRenderContext rc, ref MySrvTable desc)
{
if ((desc.BindFlag & MyBindFlag.BIND_VS) > 0)
{
for (int i = 0; i < desc.Srvs.Length; i++)
{
rc.VertexShader.SetRawSrv(desc.StartSlot + i, desc.Srvs[i]);
}
}
if ((desc.BindFlag & MyBindFlag.BIND_PS) > 0)
{
for (int i = 0; i < desc.Srvs.Length; i++)
{
rc.PixelShader.SetRawSrv(desc.StartSlot + i, desc.Srvs[i]);
}
}
MyRender11.ProcessDebugOutput();
}
void UnbindSRVRead(int resId)
{
List <int> resourceList = State.m_srvBindings.GetList(resId);
if (resourceList == null)
{
return;
}
foreach (var resourceId in resourceList)
{
DeviceContext.VertexShader.SetShaderResource(resourceId, null);
DeviceContext.PixelShader.SetShaderResource(resourceId, null);
DeviceContext.ComputeShader.SetShaderResource(resourceId, null);
}
resourceList.Clear();
MyRender11.ProcessDebugOutput();
}
private static void Render(SharpDX.Direct3D11.ShaderResourceView textureArraySRV, MyBindableResource depthRead)
{
RC.SetVS(m_vs);
if (MyRender11.DebugOverrides.OIT)
{
RC.SetPS(m_psOIT);
}
else
{
RC.SetPS(m_ps);
}
RC.SetVB(0, null, 0);
RC.SetIB(m_ib.Buffer, SharpDX.DXGI.Format.R32_UInt);
RC.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
RC.SetCB(1, m_activeListConstantBuffer);
RC.BindSRV(0, depthRead);
RC.DeviceContext.PixelShader.SetShaderResources(1, textureArraySRV);
RC.VSBindRawSRV(0, m_particleBuffer);
RC.VSBindRawSRV(1, m_aliveIndexBuffer);
RC.VSBindRawSRV(2, m_emitterStructuredBuffer);
RC.DeviceContext.VertexShader.SetShaderResource(MyCommon.SKYBOX_IBL_SLOT,
MyRender11.IsIntelBrokenCubemapsWorkaround ? Resources.MyTextures.GetView(Resources.MyTextures.IntelFallbackCubeTexId) : MyEnvironmentProbe.Instance.cubemapPrefiltered.SRV);
RC.DeviceContext.VertexShader.SetShaderResource(MyCommon.SKYBOX2_IBL_SLOT,
Resources.MyTextures.GetView(Resources.MyTextures.GetTexture(MyRender11.Environment.NightSkyboxPrefiltered, Resources.MyTextureEnum.CUBEMAP, true)));
// bind render target?
if (!MyStereoRender.Enable)
{
RC.DeviceContext.DrawIndexedInstancedIndirect(m_indirectDrawArgsBuffer.Buffer, 0);
}
else
{
MyStereoRender.DrawIndexedInstancedIndirectGPUParticles(RC, m_indirectDrawArgsBuffer.Buffer, 0);
}
MyRender11.ProcessDebugOutput();
RC.DeviceContext.PixelShader.SetShaderResource(MyCommon.SKYBOX_IBL_SLOT, null);
RC.DeviceContext.PixelShader.SetShaderResource(MyCommon.SKYBOX2_IBL_SLOT, null);
}
internal static void DrawFullscreenQuad(MyViewport?customViewport = null)
{
if (customViewport.HasValue)
{
RC.DeviceContext.Rasterizer.SetViewport(customViewport.Value.OffsetX, customViewport.Value.OffsetY, customViewport.Value.Width, customViewport.Value.Height);
}
else
{
RC.DeviceContext.Rasterizer.SetViewport(0, 0, MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y);
}
// set vertex buffer:
if (!MyStereoRender.Enable || MyStereoRender.RenderRegion == MyStereoRegion.FULLSCREEN)
{
RC.SetVB(0, m_VBFullscreen.Buffer, m_VBFullscreen.Stride);
}
else if (MyStereoRender.RenderRegion == MyStereoRegion.LEFT)
{
RC.SetVB(0, m_VBLeftPart.Buffer, m_VBLeftPart.Stride);
}
else if (MyStereoRender.RenderRegion == MyStereoRegion.RIGHT)
{
RC.SetVB(0, m_VBRightPart.Buffer, m_VBRightPart.Stride);
}
if (MyStereoRender.Enable)
{
MyStereoRender.PSBindRawCB_FrameConstants(RC);
}
RC.DeviceContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleStrip;
RC.SetIL(m_IL);
RC.SetVS(m_VSCopy);
RC.DeviceContext.Draw(4, 0);
MyRender11.ProcessDebugOutput();
RC.DeviceContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
if (MyStereoRender.Enable)
{
RC.DeviceContext.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
}
}
private void BindSRVsInternal(int slot, MyBindableResource[] bindable)
{
Array.Clear(State.m_SRVs, 0, State.m_SRVs.Length);
for (int i = 0; i < bindable.Length; i++)
{
Debug.Assert(bindable[i] as IShaderResourceBindable != null);
MyBinding binding;
State.m_bindings.TryGetValue(bindable[i].GetID(), out binding);
if (binding.WriteView == MyWriteBindingEnum.RTV || binding.WriteView == MyWriteBindingEnum.DSV)
{
DeviceContext.OutputMerger.ResetTargets();
ClearDsvRtvWriteBindings();
}
else if (binding.WriteView == MyWriteBindingEnum.UAV)
{
ComputeShaderId.TmpUav[0] = null;
DeviceContext.ComputeShader.SetUnorderedAccessViews(binding.UavSlot, ComputeShaderId.TmpUav, ComputeShaderId.TmpCount);
State.m_bindings.Remove(bindable[i].GetID());
List <int> keyList = State.m_slotToBindingKeys.GetList(slot);
if (keyList != null)
{
keyList.Remove(bindable[i].GetID());
if (keyList.Count == 0)
{
State.m_slotToBindingKeys.Remove(slot);
}
}
}
State.m_srvBindings.Add(bindable[i].GetID(), slot + i);
State.m_SRVs[i] = (bindable[i] as IShaderResourceBindable).SRV;
}
for (int i = 0; i < bindable.Length; i++)
{
DeviceContext.VertexShader.SetShaderResource(slot + i, State.m_SRVs[i]);
DeviceContext.PixelShader.SetShaderResource(slot + i, State.m_SRVs[i]);
DeviceContext.ComputeShader.SetShaderResource(slot + i, State.m_SRVs[i]);
}
MyRender11.ProcessDebugOutput();
}
internal void SetConstants(ref MyConstantsPack desc, int slot)
{
MyStageBinding key;
key.Stage = MyShaderStage.VS;
try
{
if ((desc.BindFlag & MyBindFlag.BIND_VS) > 0 && State.m_constantBindings.Get(new MyStageBinding {
Slot = slot, Stage = MyShaderStage.VS
}) != desc.CB)
{
key = new MyStageBinding {
Slot = slot, Stage = MyShaderStage.VS
};
State.m_constantBindings[key] = desc.CB;
DeviceContext.VertexShader.SetConstantBuffer(slot, desc.CB);
}
if ((desc.BindFlag & MyBindFlag.BIND_PS) > 0 && State.m_constantBindings.Get(new MyStageBinding {
Slot = slot, Stage = MyShaderStage.PS
}) != desc.CB)
{
key = new MyStageBinding {
Slot = slot, Stage = MyShaderStage.PS
};
State.m_constantBindings[key] = desc.CB;
DeviceContext.PixelShader.SetConstantBuffer(slot, desc.CB);
}
MyRender11.ProcessDebugOutput();
}
catch (Exception ex)
{
MyLog.Default.WriteLine(ex);
MyLog.Default.WriteLine(string.Format("Some additional info: slot {0}, Stage {1}, desc {2}", slot, key.Stage, desc));
MyLog.Default.WriteLine("m_constantBindings.Count: " + State.m_constantBindings.Count);
MyLog.Default.WriteLine("m_constantBindings: " + State.m_constantBindings);
throw;
}
}