public DX11RenderStateStack(DX11RenderContext context)
{
this.context = context;
this.defaultstate = new DX11RenderState();
stack = new Stack<DX11RenderState>();
this.defaultstate.Apply(context);
}
public DX11RenderStateStack(DX11RenderContext context)
{
this.context = context;
this.defaultstate = new DX11RenderState();
stack = new Stack <DX11RenderState>();
this.defaultstate.Apply(context);
}
public void Evaluate(int SpreadMax)
{
if (this.FInPreset.IsChanged
|| this.FInState.IsChanged)
{
this.FOutState.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
DX11RenderState rs;
if (this.FInState.PluginIO.IsConnected)
{
rs = this.FInState[i];
}
else
{
rs = new DX11RenderState();
}
this.AssignPreset(this.FInPreset[i].Name, rs);
this.FOutState[i] = rs;
}
}
}
public DX11RenderState Clone()
{
DX11RenderState result = new DX11RenderState();
result.Blend = this.Blend;
result.DepthStencil = this.DepthStencil;
result.Rasterizer = this.Rasterizer;
return result;
}
public DX11RenderState Clone()
{
DX11RenderState result = new DX11RenderState();
result.Blend = this.Blend;
result.DepthStencil = this.DepthStencil;
result.Rasterizer = this.Rasterizer;
return(result);
}
public DX11RenderState Clone()
{
DX11RenderState result = new DX11RenderState();
result.Blend = this.Blend;
result.DepthStencil = this.DepthStencil;
result.Rasterizer = this.Rasterizer;
result.BlendFactor = this.BlendFactor;
result.DepthStencilReference = this.DepthStencilReference;
result.Tag = this.Tag;
return(result);
}
public void Evaluate(int SpreadMax)
{
if (this.FInFillMode.IsChanged
|| this.FInCullMode.IsChanged
|| this.FInDepthBias.IsChanged
|| this.FInDepthBiasClamp.IsChanged
|| this.FInDepthClipEnable.IsChanged
|| this.FInFrontCCW.IsChanged
|| this.FInLineAAEnable.IsChanged
|| this.FInEnableMS.IsChanged
|| this.FInEnableScissor.IsChanged
|| this.FInSlopeScaleDB.IsChanged
|| this.FInState.IsChanged)
{
this.FOutState.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
DX11RenderState rs;
if (this.FInState.PluginIO.IsConnected)
{
rs = this.FInState[i].Clone();
}
else
{
rs = new DX11RenderState();
}
RasterizerStateDescription rsd = rs.Rasterizer;
rsd.FillMode = this.FInFillMode[i];
rsd.CullMode = this.FInCullMode[i];
rsd.DepthBias = this.FInDepthBias[i];
rsd.DepthBiasClamp = this.FInDepthBiasClamp[i];
rsd.IsDepthClipEnabled = this.FInDepthClipEnable[i];
rsd.IsAntialiasedLineEnabled = this.FInLineAAEnable[i];
rsd.IsFrontCounterclockwise = this.FInFrontCCW[i];
rsd.IsMultisampleEnabled = this.FInEnableMS[i];
rsd.IsScissorEnabled = this.FInEnableScissor[i];
rsd.SlopeScaledDepthBias = this.FInSlopeScaleDB[i];
rs.Rasterizer = rsd;
this.FOutState[i] = rs;
}
}
}
public void Evaluate(int SpreadMax)
{
if (this.FInAlphaCover.IsChanged
|| this.FInEnable.IsChanged
|| this.FInBlendOp.IsChanged
|| this.FInBlendOpAlpha.IsChanged
|| this.FInWriteMask.IsChanged
|| this.FInSrc.IsChanged
|| this.FInSrcAlpha.IsChanged
|| this.FInDest.IsChanged
|| this.FInDestAlpha.IsChanged)
{
this.FOutState.SliceCount = SpreadMax;
DX11RenderState rs;
if (this.FInState.PluginIO.IsConnected)
{
rs = this.FInState[0].Clone();
}
else
{
rs = new DX11RenderState();
}
BlendStateDescription bs = rs.Blend;
for (int i = 0; i < 8; i++)
{
bs.IndependentBlendEnable = true;
bs.AlphaToCoverageEnable = this.FInAlphaCover[0];
bs.RenderTargets[i].BlendEnable = this.FInEnable[i];
bs.RenderTargets[i].BlendOperation = this.FInBlendOp[i];
bs.RenderTargets[i].BlendOperationAlpha = this.FInBlendOpAlpha[i];
bs.RenderTargets[i].RenderTargetWriteMask = this.FInWriteMask[i];
bs.RenderTargets[i].SourceBlend = this.FInSrc[i];
bs.RenderTargets[i].SourceBlendAlpha = this.FInSrcAlpha[i];
bs.RenderTargets[i].DestinationBlend = this.FInDest[i];
bs.RenderTargets[i].DestinationBlendAlpha = this.FInDestAlpha[i];
}
rs.Blend = bs;
this.FOutState[0] = rs;
}
}
public void Evaluate(int SpreadMax)
{
if (this.FInState.IsChanged || this.FInReference.IsChanged)
{
this.FOutState.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
DX11RenderState rs;
if (this.FInState.PluginIO.IsConnected)
{
rs = this.FInState[i].Clone();
}
else
{
rs = new DX11RenderState();
}
rs.DepthStencilReference = this.FInReference[i];
this.FOutState[i] = rs;
}
}
}
public void Update(IPluginIO pin, DX11RenderContext context)
{
Device device = context.Device;
DeviceContext ctx = context.CurrentDeviceContext;
if (!this.deviceshaderdata.ContainsKey(context))
{
this.deviceshaderdata.Add(context, new DX11ShaderData(context));
this.deviceshaderdata[context].SetEffect(this.FShader);
}
DX11ShaderData shaderdata = this.deviceshaderdata[context];
if (this.shaderupdated)
{
shaderdata.SetEffect(this.FShader);
this.shaderupdated = false;
}
context.RenderStateStack.Push(new DX11RenderState());
this.OnBeginQuery(context);
//Clear shader stages
shaderdata.ResetShaderStages(ctx);
context.Primitives.ApplyFullTriVS();
foreach (DX11ResourcePoolEntry<DX11RenderTarget2D> rt in this.lastframetargets)
{
rt.UnLock();
}
this.lastframetargets.Clear();
DX11ObjectRenderSettings or = new DX11ObjectRenderSettings();
int wi, he;
bool preserve = false;
DX11ResourcePoolEntry<DX11RenderTarget2D> preservedtarget = null;
for (int i = 0; i < this.spmax; i++)
{
int passcounter = 0;
if (this.FInEnabled[i])
{
List<DX11ResourcePoolEntry<DX11RenderTarget2D>> locktargets = new List<DX11ResourcePoolEntry<DX11RenderTarget2D>>();
#region Manage size
DX11Texture2D initial;
if (this.FIn.PluginIO.IsConnected)
{
if (this.FInUseDefaultSize[0])
{
initial = context.DefaultTextures.WhiteTexture;
wi = (int)this.FInSize[0].X;
he = (int)this.FInSize[0].Y;
}
else
{
initial = this.FIn[i][context];
if (initial != null)
{
wi = initial.Width;
he = initial.Height;
}
else
{
initial = context.DefaultTextures.WhiteTexture;
wi = (int)this.FInSize[i].X;
he = (int)this.FInSize[i].Y;
}
}
}
else
{
initial = context.DefaultTextures.WhiteTexture;
wi = (int)this.FInSize[i].X;
he = (int)this.FInSize[i].Y;
}
#endregion
DX11RenderSettings r = new DX11RenderSettings();
r.RenderWidth = wi;
r.RenderHeight = he;
if (this.FInSemantics.PluginIO.IsConnected)
{
r.CustomSemantics.AddRange(this.FInSemantics.ToArray());
}
if (this.FInResSemantics.PluginIO.IsConnected)
{
r.ResourceSemantics.AddRange(this.FInResSemantics.ToArray());
}
this.varmanager.SetGlobalSettings(shaderdata.ShaderInstance, r);
this.varmanager.ApplyGlobal(shaderdata.ShaderInstance);
DX11Texture2D lastrt = initial;
DX11ResourcePoolEntry<DX11RenderTarget2D> lasttmp = null;
List<DX11Texture2D> rtlist = new List<DX11Texture2D>();
//Bind Initial (once only is ok)
this.BindTextureSemantic(shaderdata.ShaderInstance.Effect, "INITIAL", initial);
//Go trough all passes
EffectTechnique tech = shaderdata.ShaderInstance.Effect.GetTechniqueByIndex(tid);
for (int j = 0; j < tech.Description.PassCount; j++)
{
ImageShaderPass pi = this.varmanager.passes[j];
EffectPass pass = tech.GetPassByIndex(j);
bool isLastPass = j == tech.Description.PassCount - 1;
for (int kiter = 0; kiter < pi.IterationCount; kiter++)
{
if (passcounter > 0)
{
for (int pid = 0; pid < passcounter; pid++)
{
string pname = "PASSRESULT" + pid;
this.BindTextureSemantic(shaderdata.ShaderInstance.Effect, pname, rtlist[pid]);
}
}
Format fmt = initial.Format;
if (pi.CustomFormat)
{
fmt = pi.Format;
}
bool mips = pi.Mips || (isLastPass && FInMipLastPass[i]);
int w, h;
if (j == 0)
{
h = he;
w = wi;
}
else
{
h = pi.Reference == ImageShaderPass.eImageScaleReference.Initial ? he : lastrt.Height;
w = pi.Reference == ImageShaderPass.eImageScaleReference.Initial ? wi : lastrt.Width;
}
if (pi.DoScale)
{
if (pi.Absolute)
{
w = Convert.ToInt32(pi.ScaleVector.X);
h = Convert.ToInt32(pi.ScaleVector.Y);
}
else
{
w = Convert.ToInt32((float)w * pi.ScaleVector.X);
h = Convert.ToInt32((float)h * pi.ScaleVector.Y);
}
w = Math.Max(w, 1);
h = Math.Max(h, 1);
}
//Check format support for render target, and default to rgb8 if not
if (!context.IsSupported(FormatSupport.RenderTarget, fmt))
{
fmt = Format.R8G8B8A8_UNorm;
}
//Since device is not capable of telling us BGR not supported
if (fmt == Format.B8G8R8A8_UNorm) { fmt = Format.R8G8B8A8_UNorm; }
DX11ResourcePoolEntry<DX11RenderTarget2D> elem;
if (preservedtarget != null)
{
elem = preservedtarget;
}
else
{
elem = context.ResourcePool.LockRenderTarget(w, h, fmt, new SampleDescription(1, 0), mips, 0);
locktargets.Add(elem);
}
DX11RenderTarget2D rt = elem.Element;
if (this.FDepthIn.PluginIO.IsConnected && pi.UseDepth)
{
context.RenderTargetStack.Push(this.FDepthIn[0][context], true, elem.Element);
}
else
{
context.RenderTargetStack.Push(elem.Element);
}
if (pi.Clear)
{
elem.Element.Clear(new Color4(0, 0, 0, 0));
}
#region Check for depth/blend preset
bool validdepth = false;
bool validblend = false;
DepthStencilStateDescription ds = new DepthStencilStateDescription();
BlendStateDescription bs = new BlendStateDescription();
if (pi.DepthPreset != "")
{
try
{
ds = DX11DepthStencilStates.Instance.GetState(pi.DepthPreset);
validdepth = true;
}
catch
{
}
}
if (pi.BlendPreset != "")
{
try
{
bs = DX11BlendStates.Instance.GetState(pi.BlendPreset);
validblend = true;
}
catch
{
}
}
#endregion
if (validdepth || validblend)
{
DX11RenderState state = new DX11RenderState();
if (validdepth) { state.DepthStencil = ds; }
if (validblend) { state.Blend = bs; }
context.RenderStateStack.Push(state);
}
r.RenderWidth = w;
r.RenderHeight = h;
r.BackBuffer = elem.Element;
this.varmanager.ApplyGlobal(shaderdata.ShaderInstance);
//Apply settings (note that textures swap is handled later)
this.varmanager.ApplyPerObject(context, shaderdata.ShaderInstance, or, i);
//Bind last render target
this.BindTextureSemantic(shaderdata.ShaderInstance.Effect, "PREVIOUS", lastrt);
this.BindPassIndexSemantic(shaderdata.ShaderInstance.Effect, j);
this.BindPassIterIndexSemantic(shaderdata.ShaderInstance.Effect, kiter);
if (this.FDepthIn.PluginIO.IsConnected)
{
if (this.FDepthIn[0].Contains(context))
{
this.BindTextureSemantic(shaderdata.ShaderInstance.Effect, "DEPTHTEXTURE", this.FDepthIn[0][context]);
}
}
//Apply pass and draw quad
pass.Apply(ctx);
if (pi.ComputeData.Enabled)
{
pi.ComputeData.Dispatch(context, w, h);
context.CleanUpCS();
}
else
{
ctx.ComputeShader.Set(null);
context.Primitives.FullScreenTriangle.Draw();
ctx.OutputMerger.SetTargets(this.nullrtvs);
}
//Generate mips if applicable
if (mips) { ctx.GenerateMips(rt.SRV); }
if (!pi.KeepTarget)
{
preserve = false;
rtlist.Add(rt);
lastrt = rt;
lasttmp = elem;
preservedtarget = null;
passcounter++;
}
else
{
preserve = true;
preservedtarget = elem;
}
context.RenderTargetStack.Pop();
if (validblend || validdepth)
{
context.RenderStateStack.Pop();
}
if (pi.HasState)
{
context.RenderStateStack.Apply();
}
}
}
//Set last render target
this.FOut[i][context] = lastrt;
//Unlock all resources
foreach (DX11ResourcePoolEntry<DX11RenderTarget2D> lt in locktargets)
{
lt.UnLock();
}
//Keep lock on last rt, since don't want it overidden
lasttmp.Lock();
this.lastframetargets.Add(lasttmp);
}
else
{
this.FOut[i][context] = this.FIn[i][context];
}
}
context.RenderStateStack.Pop();
this.OnEndQuery(context);
//UnLock previous frame in applicable
//if (previoustarget != null) { context.ResourcePool.Unlock(previoustarget); }
}
public void Push(DX11RenderState state)
{
stack.Push(state);
this.Apply();
}
protected override DX11RenderState AssignPreset(string key, DX11RenderState statein)
{
statein.DepthStencil = DX11DepthStencilStates.Instance.GetState(key);
return statein;
}
protected override DX11RenderState AssignPreset(string key, DX11RenderState statein)
{
statein.Rasterizer = DX11RasterizerStates.Instance.GetState(key);
return statein;
}
public void Evaluate(int SpreadMax)
{
if (this.FInComparison.IsChanged
|| this.FInDepthWriteMask.IsChanged
|| this.FInEnableDepth.IsChanged
|| this.FInEnableStencil.IsChanged
|| this.FInState.IsChanged
|| this.FInBFComp.IsChanged
|| this.FInBFDFOp.IsChanged
|| this.FInBFFOp.IsChanged
|| this.FInBFPOp.IsChanged
|| this.FInFFComp.IsChanged
|| this.FInFFDFOp.IsChanged
|| this.FInFFFOp.IsChanged
|| this.FInFFPOp.IsChanged
|| this.FInStencilReadMask.IsChanged
|| this.FInStencilWriteMask.IsChanged)
{
this.FOutState.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
DX11RenderState rs;
if (this.FInState.PluginIO.IsConnected)
{
rs = this.FInState[i];
}
else
{
rs = new DX11RenderState();
}
DepthStencilStateDescription ds = rs.DepthStencil;
ds.DepthComparison = this.FInComparison[i];
ds.DepthWriteMask = this.FInDepthWriteMask[i];
ds.IsDepthEnabled = this.FInEnableDepth[i];
ds.IsStencilEnabled = this.FInEnableStencil[i];
int srm = Math.Min(255, Math.Max(this.FInStencilReadMask[i], 0));
int swm = Math.Min(255, Math.Max(this.FInStencilWriteMask[i], 0));
ds.StencilReadMask = Convert.ToByte(srm);
ds.StencilWriteMask = Convert.ToByte(swm);
DepthStencilOperationDescription dbf = new DepthStencilOperationDescription();
dbf.Comparison = this.FInBFComp[i];
dbf.DepthFailOperation = this.FInBFDFOp[i];
dbf.FailOperation = this.FInBFFOp[i];
dbf.PassOperation = this.FInBFPOp[i];
ds.BackFace = dbf;
DepthStencilOperationDescription dff = new DepthStencilOperationDescription();
dff.Comparison = this.FInFFComp[i];
dff.DepthFailOperation = this.FInFFDFOp[i];
dff.FailOperation = this.FInFFFOp[i];
dff.PassOperation = this.FInFFPOp[i];
ds.FrontFace = dff;
rs.DepthStencil = ds;
this.FOutState[i] = rs;
}
}
}
public void Render(DX11RenderContext context)
{
if (this.lasthandle != this.Handle)
{
if (this.swapchain != null)
{
if (this.swapchain.Contains(context)) { this.swapchain.Dispose(context); }
}
this.lasthandle = this.Handle;
}
if (!this.swapchain.Contains(context))
{
this.swapchain[context] = new DX11SwapChain(context, this.Handle,
SlimDX.DXGI.Format.R8G8B8A8_UNorm, new SampleDescription(1, 0),60,1);
}
if (this.resized)
{
this.swapchain[context].Resize();
}
if (this.FEnabled[0])
{
context.CurrentDeviceContext.ClearRenderTargetView(this.swapchain[context].RTV,new SlimDX.Color4(0,0,0,0));
}
if (this.FIn.IsConnected && this.spreadMax > 0 && this.FEnabled[0])
{
int id = this.FIndex[0];
if (this.FIn[id].Contains(context) && this.FIn[id][context] != null)
{
context.RenderTargetStack.Push(this.swapchain[context]);
var rs = new DX11RenderState();
if (FAlpha[0])
{
rs.Blend = DX11BlendStates.Instance.GetState("Blend");
context.CurrentDeviceContext.ClearRenderTargetView(this.swapchain[context].RTV, FInBgColor[0].Color);
}
context.RenderStateStack.Push(rs);
context.CleanShaderStages();
context.Primitives.FullTriVS.GetVariableBySemantic("TEXTURE").AsResource().SetResource(this.FIn[id][context].SRV);
EffectSamplerVariable samplervariable = context.Primitives.FullTriVS.GetVariableByName("linSamp").AsSampler();
SamplerState state = null;
if (this.FInSamplerState.IsConnected)
{
state = SamplerState.FromDescription(context.Device, this.FInSamplerState[0]);
samplervariable.SetSamplerState(0, state);
}
else
{
samplervariable.UndoSetSamplerState(0);
}
context.Primitives.FullScreenTriangle.Bind(null);
context.Primitives.ApplyFullTri();
context.Primitives.FullScreenTriangle.Draw();
context.RenderStateStack.Pop();
context.RenderTargetStack.Pop();
context.CleanUpPS();
samplervariable.UndoSetSamplerState(0); //undo as can be used in other places
if (state != null)
{
state.Dispose();
}
}
}
}
public void Push(DX11RenderState state)
{
stack.Push(state);
this.Apply();
}
protected abstract DX11RenderState AssignPreset(string key,DX11RenderState statein);
public void Render(DX11RenderContext context)
{
if (this.lasthandle != this.Handle)
{
if (this.swapchain != null)
{
if (this.swapchain.Contains(context)) { this.swapchain.Dispose(context); }
}
this.lasthandle = this.Handle;
}
if (!this.swapchain.Contains(context))
{
this.swapchain[context] = new DX11SwapChain(context, this.Handle, SlimDX.DXGI.Format.R8G8B8A8_UNorm, new SampleDescription(1, 0));
}
if (this.resized)
{
this.swapchain[context].Resize();
}
if (this.FEnabled[0])
{
context.CurrentDeviceContext.ClearRenderTargetView(this.swapchain[context].RTV,new SlimDX.Color4(0,0,0,0));
}
if (this.FIn.PluginIO.IsConnected && this.FEnabled[0])
{
int id = this.FIndex[0];
if (this.FIn[id].Contains(context))
{
context.RenderTargetStack.Push(this.swapchain[context]);
var rs = new DX11RenderState();
if (FAlpha[0])
{
rs.Blend = DX11BlendStates.Instance.GetState("Blend");
context.CurrentDeviceContext.ClearRenderTargetView(this.swapchain[context].RTV, FInBgColor[0].Color);
}
context.RenderStateStack.Push(rs);
context.CleanShaderStages();
context.Primitives.FullTriVS.GetVariableBySemantic("TEXTURE").AsResource().SetResource(this.FIn[id][context].SRV);
context.Primitives.FullScreenTriangle.Bind(null);
context.Primitives.ApplyFullTri();
context.Primitives.FullScreenTriangle.Draw();
context.RenderStateStack.Pop();
context.RenderTargetStack.Pop();
context.CleanUpPS();
}
}
}