public void Update(IPluginIO pin, DX11RenderContext context)
{
if (this.CalculateSpreadMax() == 0)
{
return;
}
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);
shaderdata.Update(this.FInTechnique[0].Index, 0, this.FIn);
this.shaderupdated = false;
}
if (this.FInEnabled[0] && this.FIn.PluginIO.IsConnected)
{
//Clear shader stages (important here)
shaderdata.ResetShaderStages(ctx);
if (this.FIn.IsChanged || this.FInTechnique.IsChanged || shaderdata.LayoutValid.Count == 0)
{
shaderdata.Update(this.FInTechnique[0].Index, 0, this.FIn);
}
if (shaderdata.IsLayoutValid(0) && this.varmanager.SetGlobalSettings(shaderdata.ShaderInstance,this.settings))
{
this.OnBeginQuery(context);
this.settings = new DX11RenderSettings();
this.settings.RenderWidth = 1;
this.settings.RenderHeight = 1;
this.settings.View = this.FInView[0];
this.settings.Projection = this.FInProjection[0];
this.settings.ViewProjection = this.settings.View * this.settings.Projection;
this.settings.RenderDepth = 1;
this.settings.BackBuffer = null;
if (this.FInSemantics.PluginIO.IsConnected)
{
this.settings.CustomSemantics.AddRange(this.FInSemantics.ToArray());
}
if (this.FInResSemantics.PluginIO.IsConnected)
{
this.settings.ResourceSemantics.AddRange(this.FInResSemantics.ToArray());
}
this.varmanager.ApplyGlobal(shaderdata.ShaderInstance);
if (this.clone == null || this.FIn.IsChanged || this.FInAsAuto.IsChanged || this.FInMaxElements.IsChanged || this.FInLayout.IsChanged || this.FInAutoLayout.IsChanged)
{
if (this.buffer != null) { this.buffer.Dispose(); }
bool customlayout = this.FInLayout.PluginIO.IsConnected || this.FInAutoLayout[0];
InputElement[] elems = null;
int size = 0;
if (this.FInAutoLayout[0])
{
elems = this.FShader.DefaultEffect.GetTechniqueByIndex(tid).GetPassByIndex(0).GetStreamOutputLayout(out size);
}
else
{
if (customlayout)
{
elems = this.BindInputLayout(out size);
}
}
#region Vertex Geom
if (this.FIn[0][context] is DX11VertexGeometry)
{
if (!this.FInAsAuto[0])
{
DX11VertexGeometry vg = (DX11VertexGeometry)this.FIn[0][context].ShallowCopy();
int vsize = customlayout ? size : vg.VertexSize;
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, vsize, vg.VerticesCount);
if (customlayout) { vg.VertexSize = vsize; }
vg.VertexBuffer = vbo;
this.clone = vg;
this.buffer = vbo;
}
else
{
DX11VertexGeometry vg = (DX11VertexGeometry)this.FIn[0][context].ShallowCopy();
int maxv = vg.VerticesCount;
if (this.FInMaxElements[0] > 0)
{
maxv = this.FInMaxElements[0];
}
int vsize = customlayout ? size : vg.VertexSize;
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, vsize, maxv);
vg.VertexBuffer = vbo;
vg.AssignDrawer(new DX11VertexAutoDrawer());
if (customlayout) { vg.VertexSize = vsize; }
this.clone = vg;
this.buffer = vbo;
}
}
#endregion
#region Inxexed geom
if (this.FIn[0][context] is DX11IndexedGeometry)
{
if (!this.FInAsAuto[0])
{
DX11IndexedGeometry ig = (DX11IndexedGeometry)this.FIn[0][context].ShallowCopy();
int vsize = customlayout ? size : ig.VertexSize;
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, vsize, ig.VerticesCount);
ig.VertexBuffer = vbo;
if (customlayout) { ig.VertexSize = vsize; }
this.clone = ig;
this.buffer = vbo;
}
else
{
//Need to rebind indexed geom as vertex
DX11IndexedGeometry ig = (DX11IndexedGeometry)this.FIn[0][context];
int maxv = ig.VerticesCount;
if (this.FInMaxElements[0] > 0)
{
maxv = this.FInMaxElements[0];
}
int vsize = customlayout ? size : ig.VertexSize;
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, vsize, maxv);
//Copy a new Vertex buffer with stream out
DX11VertexGeometry vg = new DX11VertexGeometry(context);
vg.AssignDrawer(new DX11VertexAutoDrawer());
vg.BoundingBox = ig.BoundingBox;
vg.HasBoundingBox = ig.HasBoundingBox;
vg.InputLayout = ig.InputLayout;
vg.Topology = ig.Topology;
vg.VertexBuffer = vbo;
vg.VertexSize = ig.VertexSize;
vg.VerticesCount = ig.VerticesCount;
if (customlayout) { vg.VertexSize = vsize; }
this.clone = vg;
this.buffer = vbo;
}
}
#endregion
#region Null geom
if (this.FIn[0][context] is DX11NullGeometry)
{
DX11NullGeometry ng = (DX11NullGeometry)this.FIn[0][context];
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, size, this.FInMaxElements[0]);
//Copy a new Vertex buffer with stream out
DX11VertexGeometry vg = new DX11VertexGeometry(context);
vg.AssignDrawer(new DX11VertexAutoDrawer());
vg.BoundingBox = ng.BoundingBox;
vg.HasBoundingBox = ng.HasBoundingBox;
vg.InputLayout = ng.InputLayout;
vg.Topology = ng.Topology;
vg.VertexBuffer = vbo;
vg.VertexSize = size;
vg.VerticesCount = this.FInMaxElements[0];
this.clone = vg;
this.buffer = vbo;
}
#endregion
#region Index Only geom
if (this.FIn[0][context] is DX11IndexOnlyGeometry)
{
DX11IndexOnlyGeometry ng = (DX11IndexOnlyGeometry)this.FIn[0][context];
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, size, this.FInMaxElements[0]);
//Copy a new Vertex buffer with stream out
DX11VertexGeometry vg = new DX11VertexGeometry(context);
vg.AssignDrawer(new DX11VertexAutoDrawer());
vg.BoundingBox = ng.BoundingBox;
vg.HasBoundingBox = ng.HasBoundingBox;
vg.InputLayout = ng.InputLayout;
vg.Topology = ng.Topology;
vg.VertexBuffer = vbo;
vg.VertexSize = size;
vg.VerticesCount = this.FInMaxElements[0];
this.clone = vg;
this.buffer = vbo;
}
#endregion
if (customlayout) { this.clone.InputLayout = elems; }
if (this.FOutBuffer[0][context] != null)
{
this.FOutBuffer[0][context].SRV.Dispose();
}
if (context.ComputeShaderSupport)
{
this.FOutBuffer[0][context] = new DX11RawBuffer(context, this.buffer);
}
else
{
this.FOutBuffer[0][context] = null;
}
}
ctx.StreamOutput.SetTargets(new StreamOutputBufferBinding(this.buffer, 0));
shaderdata.SetInputAssembler(ctx, this.FIn[0][context], 0);
DX11ObjectRenderSettings ors = new DX11ObjectRenderSettings();
ors.DrawCallIndex = 0;
ors.Geometry = this.FIn[0][context];
ors.WorldTransform = Matrix.Identity;
this.varmanager.ApplyPerObject(context, shaderdata.ShaderInstance, ors, 0);
shaderdata.ApplyPass(ctx);
this.FIn[0][context].Draw();
ctx.StreamOutput.SetTargets(null);
this.FOut[0][context] = this.clone;
this.OnEndQuery(context);
}
else
{
this.FOut[0][context] = this.FIn[0][context];
}
}
else
{
this.FOut[0][context] = this.FIn[0][context];
}
}
public void SetInputAssembler(DeviceContext ctx, IDX11Geometry geom, int slice)
{
geom.Bind(this.layouts[slice % this.layouts.Count]);
}
public BulletMesh(IDX11Geometry geometry)
{
this.Geometry = geometry;
}
public void Render(IPluginIO pin, DX11RenderContext context, DX11RenderSettings settings)
{
Device device = context.Device;
DeviceContext ctx = context.CurrentDeviceContext;
bool popstate = false;
bool multistate = this.FInState.IsConnected && this.FInState.SliceCount > 1;
if (this.FInEnabled[0])
{
//In that case we do not care about geometry, but only apply pass for globals
if (settings.RenderHint == eRenderHint.ApplyOnly)
{
DX11ShaderData sdata = this.deviceshaderdata[context];
this.varmanager.SetGlobalSettings(sdata.ShaderInstance, settings);
this.varmanager.ApplyGlobal(sdata.ShaderInstance);
DX11ObjectRenderSettings oset = new DX11ObjectRenderSettings();
oset.DrawCallIndex = 0;
oset.Geometry = null;
oset.IterationCount = 1;
oset.IterationIndex = 0;
oset.WorldTransform = this.mworld[0 % this.mworldcount];
this.varmanager.ApplyPerObject(context, sdata.ShaderInstance, oset, 0);
sdata.ApplyPass(ctx);
if (this.FInLayer.IsConnected)
{
this.FInLayer[0][context].Render(this.FInLayer.PluginIO, context, settings);
}
return;
}
if (settings.RenderHint == eRenderHint.Collector)
{
if (this.FGeometry.PluginIO.IsConnected)
{
DX11ObjectGroup group = new DX11ObjectGroup();
group.ShaderName = this.Source.Name;
group.Semantics.AddRange(settings.CustomSemantics);
if (this.FGeometry.SliceCount == 1)
{
IDX11Geometry g = this.FGeometry[0][context];
if (g.Tag != null)
{
DX11RenderObject o = new DX11RenderObject();
o.ObjectType = g.PrimitiveType;
o.Descriptor = g.Tag;
o.Transforms = new Matrix[spmax];
for (int i = 0; i < this.spmax; i++)
{
o.Transforms[i] = this.mworld[i % this.mworldcount];
}
group.RenderObjects.Add(o);
settings.SceneDescriptor.Groups.Add(group);
}
}
else
{
for (int i = 0; i < this.spmax; i++)
{
IDX11Geometry g = this.FGeometry[i][context];
if (g.Tag != null)
{
DX11RenderObject o = new DX11RenderObject();
o.ObjectType = g.PrimitiveType;
o.Descriptor = g.Tag;
o.Transforms = new Matrix[1];
o.Transforms[0] = this.mworld[i % this.mworldcount];
group.RenderObjects.Add(o);
}
}
settings.SceneDescriptor.Groups.Add(group);
}
}
return;
}
DX11ShaderData shaderdata = this.deviceshaderdata[context];
if ((shaderdata.IsValid &&
(this.geomconnected || settings.Geometry != null) &&
this.spmax > 0 && this.varmanager.SetGlobalSettings(shaderdata.ShaderInstance, settings)) ||
this.FInApplyOnly[0])
{
this.OnBeginQuery(context);
//Select preferred technique if available
if (settings.PreferredTechniques.Count == 0 && this.techniqueindex != this.FInTechnique[0].Index)
{
this.techniqueindex = this.FInTechnique[0].Index;
this.techniquechanged = true;
}
else if (settings.PreferredTechniques.Count > 0)
{
int i = settings.GetPreferredTechnique(this.FShader);
if (i == -1)
{
i = this.FInTechnique[0].Index;
}
if (i != this.techniqueindex)
{
this.techniqueindex = i;
this.techniquechanged = true;
}
}
//Need to build input layout
if (this.FGeometry.IsChanged || this.techniquechanged || shaderdata.LayoutValid.Count == 0)
{
shaderdata.Update(this.techniqueindex, 0, this.FGeometry);
this.FOutLayoutValid.AssignFrom(shaderdata.LayoutValid);
this.FOutLayoutMsg.AssignFrom(shaderdata.LayoutMsg);
int errorCount = 0;
StringBuilder sbMsg = new StringBuilder();
sbMsg.Append("Invalid layout detected for slices:");
for (int i = 0; i < shaderdata.LayoutValid.Count; i++)
{
if (shaderdata.LayoutValid[i] == false)
{
errorCount++;
sbMsg.Append(i + ",");
}
}
if (errorCount > 0)
{
this.FHost.Log(TLogType.Warning, sbMsg.ToString());
}
this.techniquechanged = false;
}
if (this.stateconnected && !multistate)
{
context.RenderStateStack.Push(this.FInState[0]);
popstate = true;
}
ShaderPipelineState pipelineState = null;
if (!settings.PreserveShaderStages)
{
shaderdata.ResetShaderStages(ctx);
}
else
{
pipelineState = new ShaderPipelineState(context);
}
settings.DrawCallCount = spmax; //Set number of draw calls
this.varmanager.ApplyGlobal(shaderdata.ShaderInstance);
//IDX11Geometry drawgeom = null;
objectsettings.Geometry = null;
DX11Resource <IDX11Geometry> pg = null;
bool doOrder = false;
List <int> orderedSlices = null;
if (settings.LayerOrder != null && settings.LayerOrder.Enabled)
{
this.orderedObjectSettings.Clear();
for (int i = 0; i < this.spmax; i++)
{
DX11ObjectRenderSettings objSettings = new DX11ObjectRenderSettings();
objSettings.DrawCallIndex = i;
objSettings.Geometry = null;
objSettings.IterationCount = 1;
objSettings.IterationIndex = 0;
objSettings.WorldTransform = this.mworld[i % this.mworldcount];
this.orderedObjectSettings.Add(objSettings);
}
orderedSlices = settings.LayerOrder.Reorder(settings, orderedObjectSettings);
doOrder = true;
}
int drawCount = doOrder ? orderedSlices.Count : this.spmax;
if (this.spmax == 0)
{
drawCount = 0;
}
for (int i = 0; i < drawCount; i++)
{
int idx = doOrder ? orderedSlices[i] : i;
if (multistate)
{
context.RenderStateStack.Push(this.FInState[idx]);
}
if (shaderdata.IsLayoutValid(idx) || settings.Geometry != null)
{
objectsettings.IterationCount = this.FIter[idx];
for (int k = 0; k < objectsettings.IterationCount; k++)
{
objectsettings.IterationIndex = k;
if (settings.Geometry == null)
{
if (this.FGeometry[idx] != pg)
{
pg = this.FGeometry[idx];
objectsettings.Geometry = pg[context];
shaderdata.SetInputAssembler(ctx, objectsettings.Geometry, idx);
}
}
else
{
objectsettings.Geometry = settings.Geometry;
shaderdata.SetInputAssembler(ctx, objectsettings.Geometry, idx);
}
//Prepare settings
objectsettings.DrawCallIndex = idx;
objectsettings.WorldTransform = this.mworld[idx % this.mworldcount];
if (settings.ValidateObject(objectsettings))
{
this.varmanager.ApplyPerObject(context, shaderdata.ShaderInstance, this.objectsettings, idx);
shaderdata.ApplyPass(ctx);
if (settings.DepthOnly)
{
ctx.PixelShader.Set(null);
}
if (settings.PostPassAction != null)
{
settings.PostPassAction(context);
}
objectsettings.Geometry.Draw();
shaderdata.ShaderInstance.CleanUp();
}
}
}
if (multistate)
{
context.RenderStateStack.Pop();
}
if (settings.PostShaderAction != null)
{
settings.PostShaderAction(context);
}
}
if (pipelineState != null)
{
pipelineState.Restore(context);
}
this.OnEndQuery(context);
}
//this.query.End();
}
if (popstate)
{
context.RenderStateStack.Pop();
}
else
{
//Since shaders can define their own states, reapply top of the stack
context.RenderStateStack.Apply();
}
if (this.FInLayer.IsConnected && this.FInEnabled[0])
{
this.FInLayer[0][context].Render(this.FInLayer.PluginIO, context, settings);
}
}
private static IDX11Geometry AssignInstancedDrawer(DrawGeometryDescription desc, IDX11Geometry geometry)
{
var indexedGeometry = geometry as DX11IndexedGeometry;
if (indexedGeometry != null)
{
if (!(indexedGeometry.Drawer is DX11InstancedIndexedDrawer))
{
indexedGeometry = (DX11IndexedGeometry)indexedGeometry.ShallowCopy();
var drawer = new DX11InstancedIndexedDrawer();
drawer.InstanceCount = desc.InstanceCount;
drawer.StartInstanceLocation = 0;
indexedGeometry.AssignDrawer(drawer);
geometry = indexedGeometry;
}
}
else
{
var vertexGeometry = geometry as DX11VertexGeometry;
if (vertexGeometry != null)
{
if (!(vertexGeometry.Drawer is DX11InstancedVertexDrawer))
{
vertexGeometry = (DX11VertexGeometry)vertexGeometry.ShallowCopy();
var drawer = new DX11InstancedVertexDrawer();
drawer.InstanceCount = desc.InstanceCount;
drawer.StartInstanceLocation = 0;
vertexGeometry.AssignDrawer(drawer);
geometry = vertexGeometry;
}
}
}
return(geometry);
}
public void Update(DX11RenderContext context)
{
if (this.CalculateSpreadMax() == 0)
{
return;
}
Device device = context.Device;
DeviceContext ctx = context.CurrentDeviceContext;
if (!this.deviceshaderdata.Contains(context))
{
this.deviceshaderdata[context] = new DX11ShaderData(context, this.FShader);
}
if (!this.shaderVariableCache.Contains(context))
{
this.shaderVariableCache[context] = new DX11ShaderVariableCache(context, this.deviceshaderdata[context].ShaderInstance, this.varmanager);
}
DX11ShaderData shaderdata = this.deviceshaderdata[context];
shaderdata.Update(this.FInTechnique[0].Index, 0, this.FIn);
bool customlayout = this.FInLayout.IsConnected || this.FInAutoLayout[0];
if (this.techniquechanged || this.FInLayout.IsChanged || this.FInAutoLayout.IsChanged)
{
elems = null;
int size = 0;
if (this.FInAutoLayout[0])
{
elems = this.FShader.DefaultEffect.GetTechniqueByIndex(tid).GetPassByIndex(0).GetStreamOutputLayout(out size);
}
else
{
if (customlayout)
{
elems = this.BindInputLayout(out size);
}
}
this.layoutsize = size;
}
if (this.FInEnabled[0] && this.FIn.IsConnected)
{
//Clear shader stages (important here)
shaderdata.ResetShaderStages(ctx);
if (this.FIn.IsChanged || this.techniquechanged || shaderdata.LayoutValid.Count == 0)
{
shaderdata.Update(this.FInTechnique[0].Index, 0, this.FIn);
this.techniquechanged = false;
}
if (shaderdata.IsLayoutValid(0) && this.varmanager.SetGlobalSettings(shaderdata.ShaderInstance, this.settings))
{
this.OnBeginQuery(context);
this.settings = new DX11RenderSettings();
this.settings.RenderWidth = 1;
this.settings.RenderHeight = 1;
this.settings.View = this.FInView[0];
this.settings.Projection = this.FInProjection[0];
this.settings.ViewProjection = this.settings.View * this.settings.Projection;
this.settings.RenderDepth = 1;
this.settings.BackBuffer = null;
if (this.FInSemantics.IsConnected)
{
this.settings.CustomSemantics.AddRange(this.FInSemantics.ToArray());
}
if (this.FInResSemantics.IsConnected)
{
this.settings.ResourceSemantics.AddRange(this.FInResSemantics.ToArray());
}
var variableCache = this.shaderVariableCache[context];
variableCache.ApplyGlobals(settings);
if (this.clone == null || this.FIn.IsChanged || this.FInAsAuto.IsChanged || this.FInMaxElements.IsChanged || this.FInLayout.IsChanged || this.FInAutoLayout.IsChanged)
{
if (this.buffer != null)
{
this.buffer.Dispose();
}
#region Vertex Geom
if (this.FIn[0][context] is DX11VertexGeometry)
{
if (!this.FInAsAuto[0])
{
DX11VertexGeometry vg = (DX11VertexGeometry)this.FIn[0][context].ShallowCopy();
int vsize = customlayout ? this.layoutsize : vg.VertexSize;
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, vsize, vg.VerticesCount);
if (customlayout)
{
vg.VertexSize = vsize;
}
vg.VertexBuffer = vbo;
this.clone = vg;
this.buffer = vbo;
}
else
{
DX11VertexGeometry vg = (DX11VertexGeometry)this.FIn[0][context].ShallowCopy();
int maxv = vg.VerticesCount;
if (this.FInMaxElements[0] > 0)
{
maxv = this.FInMaxElements[0];
}
int vsize = customlayout ? this.layoutsize : vg.VertexSize;
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, vsize, maxv);
vg.VertexBuffer = vbo;
vg.AssignDrawer(new DX11VertexAutoDrawer());
if (customlayout)
{
vg.VertexSize = vsize;
}
this.clone = vg;
this.buffer = vbo;
}
}
#endregion
#region Inxexed geom
if (this.FIn[0][context] is DX11IndexedGeometry)
{
if (!this.FInAsAuto[0])
{
DX11IndexedGeometry ig = (DX11IndexedGeometry)this.FIn[0][context].ShallowCopy();
int vsize = customlayout ? this.layoutsize : ig.VertexSize;
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, vsize, ig.VerticesCount);
ig.VertexBuffer = vbo;
if (customlayout)
{
ig.VertexSize = vsize;
}
this.clone = ig;
this.buffer = vbo;
}
else
{
//Need to rebind indexed geom as vertex
DX11IndexedGeometry ig = (DX11IndexedGeometry)this.FIn[0][context];
int maxv = ig.VerticesCount;
if (this.FInMaxElements[0] > 0)
{
maxv = this.FInMaxElements[0];
}
int vsize = customlayout ? this.layoutsize : ig.VertexSize;
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, vsize, maxv);
//Copy a new Vertex buffer with stream out
DX11VertexGeometry vg = new DX11VertexGeometry(context);
vg.AssignDrawer(new DX11VertexAutoDrawer());
vg.BoundingBox = ig.BoundingBox;
vg.HasBoundingBox = ig.HasBoundingBox;
vg.InputLayout = ig.InputLayout;
vg.Topology = ig.Topology;
vg.VertexBuffer = vbo;
vg.VertexSize = ig.VertexSize;
vg.VerticesCount = ig.VerticesCount;
if (customlayout)
{
vg.VertexSize = vsize;
}
this.clone = vg;
this.buffer = vbo;
}
}
#endregion
#region Null geom
if (this.FIn[0][context] is DX11NullGeometry)
{
DX11NullGeometry ng = (DX11NullGeometry)this.FIn[0][context];
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, this.layoutsize, this.FInMaxElements[0]);
//Copy a new Vertex buffer with stream out
DX11VertexGeometry vg = new DX11VertexGeometry(context);
vg.AssignDrawer(new DX11VertexAutoDrawer());
vg.BoundingBox = ng.BoundingBox;
vg.HasBoundingBox = ng.HasBoundingBox;
vg.InputLayout = ng.InputLayout;
vg.Topology = ng.Topology;
vg.VertexBuffer = vbo;
vg.VertexSize = this.layoutsize;
vg.VerticesCount = this.FInMaxElements[0];
this.clone = vg;
this.buffer = vbo;
}
#endregion
#region Index Only geom
if (this.FIn[0][context] is DX11IndexOnlyGeometry)
{
DX11IndexOnlyGeometry ng = (DX11IndexOnlyGeometry)this.FIn[0][context];
Buffer vbo = BufferHelper.CreateStreamOutBuffer(context, this.layoutsize, this.FInMaxElements[0]);
//Copy a new Vertex buffer with stream out
DX11VertexGeometry vg = new DX11VertexGeometry(context);
vg.AssignDrawer(new DX11VertexAutoDrawer());
vg.BoundingBox = ng.BoundingBox;
vg.HasBoundingBox = ng.HasBoundingBox;
vg.InputLayout = ng.InputLayout;
vg.Topology = ng.Topology;
vg.VertexBuffer = vbo;
vg.VertexSize = this.layoutsize;
vg.VerticesCount = this.FInMaxElements[0];
this.clone = vg;
this.buffer = vbo;
}
#endregion
if (customlayout)
{
this.clone.InputLayout = elems;
}
if (this.FOutBuffer[0][context] != null)
{
this.FOutBuffer[0][context].SRV.Dispose();
}
if (context.ComputeShaderSupport)
{
this.FOutBuffer[0][context] = new DX11RawBuffer(context, this.buffer);
}
else
{
this.FOutBuffer[0][context] = null;
}
}
ctx.StreamOutput.SetTargets(new StreamOutputBufferBinding(this.buffer, 0));
shaderdata.SetInputAssembler(ctx, this.FIn[0][context], 0);
DX11ObjectRenderSettings ors = new DX11ObjectRenderSettings();
ors.DrawCallIndex = 0;
ors.Geometry = this.FIn[0][context];
ors.WorldTransform = Matrix.Identity;
variableCache.ApplySlice(ors, 0);
shaderdata.ApplyPass(ctx);
this.FIn[0][context].Draw();
ctx.StreamOutput.SetTargets(null);
this.FOut[0][context] = this.clone;
this.OnEndQuery(context);
}
else
{
this.FOut[0][context] = this.FIn[0][context];
}
}
else
{
this.FOut[0][context] = this.FIn[0][context];
}
}
