public QuadShaderDeviceData(DX11RenderContext context)
{
string basepath = "VVVV.DX11.Nodes.effects.quad.fx";
DX11Effect effect = DX11Effect.FromResource(Assembly.GetExecutingAssembly(), basepath);
quadshader = new DX11ShaderInstance(context, effect);
texturevariable = quadshader.Effect.GetVariableBySemantic("INPUTTEXTURE").AsResource();
samplervariable = quadshader.Effect.GetVariableBySemantic("SAMPLERSTATE").AsSampler();
Quad quad = new Quad();
quad.Size = new Vector2(1.0f);
quadgeometry = context.Primitives.QuadNormals(quad);
quadlayouts = new List <InputLayout>();
for (int i = 0; i < 4; i++)
{
InputLayout layout;
quadshader.SelectTechnique(i);
bool res = quadgeometry.ValidateLayout(quadshader.GetPass(0), out layout);
quadlayouts.Add(layout);
}
}
public override void Apply(DX11ShaderInstance shaderinstance, DX11RenderSettings settings)
{
if (settings.ReadBuffer != null)
{
shaderinstance.SetByName(this.Name, settings.ReadBuffer.SRV);
}
}
public override void SetVariable(DX11ShaderInstance shaderinstance, int slice)
{
if (this.pin.PluginIO.IsConnected)
{
if (this.pin.IsChanged)
{
if (this.state != null)
{
this.state.Dispose(); this.state = null;
}
}
if (this.state == null || this.state.Disposed)
{
this.state = SamplerState.FromDescription(shaderinstance.RenderContext.Device, this.pin[0]);
}
shaderinstance.SetByName(this.Name, this.state);
}
else
{
if (this.state != null)
{
this.state.Dispose();
this.state = null;
shaderinstance.SetByName(this.Name, this.state);
}
}
}
public void SetEffect(DX11Effect shader)
{
//Create
if (this.shader == null)
{
this.shader = shader;
if (shader.IsCompiled)
{
this.shaderinstance = new DX11ShaderInstance(this.context, shader.ByteCode);
this.UpdateTechnique();
}
}
else
{
if (shader.IsCompiled)
{
//Update shader
if (shader != this.shader)
{
//Dispose old effect if applicable
this.shader = shader;
if (this.shaderinstance != null)
{
this.shaderinstance.Dispose();
}
this.shaderinstance = new DX11ShaderInstance(this.context, shader.ByteCode);
this.UpdateTechnique();
this.DisposeLayouts();
}
}
}
}
public void Apply(DX11ShaderInstance instance, DX11RenderSettings settings, DX11ObjectRenderSettings objectsettings)
{
foreach (string rv in this.variables.Keys)
{
this.variables[rv].Apply(instance, settings, objectsettings);
}
}
public override void Apply(DX11ShaderInstance shaderinstance, DX11RenderSettings settings, DX11ObjectRenderSettings obj)
{
if (obj.Geometry != null)
{
if (obj.Geometry.HasBoundingBox)
{
Vector3 min = obj.Geometry.BoundingBox.Minimum;
Vector3 scale = obj.Geometry.BoundingBox.Maximum - obj.Geometry.BoundingBox.Minimum;
scale.X = scale.X != 0.0f ? scale.X : 1.0f;
scale.Y = scale.Y != 0.0f ? scale.Y : 1.0f;
scale.Z = scale.Z != 0.0f ? scale.Z : 1.0f;
Matrix m = Matrix.Scaling(scale);
m.M41 = min.X;
m.M42 = min.Y;
m.M43 = min.Z;
shaderinstance.SetByName(this.Name, Matrix.Invert(m));
}
else
{
shaderinstance.SetByName(this.Name, m);
}
}
else
{
shaderinstance.SetByName(this.Name, m);
}
}
public void ApplySlice(DX11ShaderInstance instance, int slice)
{
foreach (IShaderPin sp in spreadedpins)
{
sp.SetVariable(instance, slice);
}
}
public override Action <int> CreateAction(DX11ShaderInstance instance)
{
var sv = instance.Effect.GetVariableByName(this.Name).AsResource();
List <EffectScalarVariable> sizeOfVar = new List <EffectScalarVariable>();
for (int i = 0; i < instance.Effect.Description.GlobalVariableCount; i++)
{
var v = instance.Effect.GetVariableByIndex(i);
if (v.GetVariableType().Description.TypeName == "uint" && v.Description.Semantic == "SIZEOF" && v.Reference(this.Name))
{
sizeOfVar.Add(v.AsScalar());
}
}
if (sizeOfVar.Count == 0)
{
return((i) =>
{
var resource = this.GetResource(instance.RenderContext, i);
sv.SetResource(resource != null ? resource.SRV : null);
});
}
else
{
return((i) =>
{
var resource = this.GetResource(instance.RenderContext, i);
sv.SetResource(resource != null ? resource.SRV : null);
for (int j = 0; j < sizeOfVar.Count; j++)
{
sizeOfVar[j].Set(resource != null ? resource.ElementCount : 0);
}
});
}
}
public override Action <int> CreateAction(DX11ShaderInstance instance)
{
var sv = instance.Effect.GetVariableByName(this.Name).AsResource();
List <EffectVectorVariable> sizeOfVar = new List <EffectVectorVariable>();
List <EffectVectorVariable> invSizeOfVar = new List <EffectVectorVariable>();
for (int i = 0; i < instance.Effect.Description.GlobalVariableCount; i++)
{
var v = instance.Effect.GetVariableByIndex(i);
if (v.GetVariableType().Description.TypeName == "float3" && v.Description.Semantic == "SIZEOF" && v.Reference(this.Name))
{
sizeOfVar.Add(v.AsVector());
}
if (v.GetVariableType().Description.TypeName == "float3" && v.Description.Semantic == "INVSIZEOF" && v.Reference(this.Name))
{
invSizeOfVar.Add(v.AsVector());
}
}
if (sizeOfVar.Count == 0 && invSizeOfVar.Count == 0)
{
return((i) =>
{
var res = this.GetResource(instance.RenderContext, i);
sv.SetResource(res != null ? res.SRV : null);
});
}
else
{
return((i) =>
{
var resource = this.GetResource(instance.RenderContext, i);
sv.SetResource(resource != null ? resource.SRV : null);
if (resource != null)
{
for (int j = 0; j < sizeOfVar.Count; j++)
{
sizeOfVar[j].Set(new Vector3(resource.Width, resource.Height, resource.Depth));
}
for (int j = 0; j < invSizeOfVar.Count; j++)
{
invSizeOfVar[j].Set(new Vector3(1.0f / resource.Width, 1.0f / resource.Height, 1.0f / resource.Depth));
}
}
else
{
for (int j = 0; j < sizeOfVar.Count; j++)
{
sizeOfVar[j].Set(new Vector3(1, 1, 1));
}
for (int j = 0; j < invSizeOfVar.Count; j++)
{
invSizeOfVar[j].Set(new Vector3(1, 1, 1));
}
}
});
}
}
public ImageShaderInfo(DX11ShaderInstance shader)
{
var effect = shader.Effect;
this.techniqueInfo = new ImageShaderTechniqueInfo[effect.Description.TechniqueCount];
int maxPassCount = 0;
for (int i = 0; i < this.techniqueInfo.Length; i++)
{
this.techniqueInfo[i] = new ImageShaderTechniqueInfo(effect.GetTechniqueByIndex(i));
maxPassCount = this.techniqueInfo[i].PassCount > maxPassCount ? this.techniqueInfo[i].PassCount : maxPassCount;
}
//Set list of max pass count
this.passResultVariableArray = new List <EffectResourceVariable> [maxPassCount];
for (int i = 0; i < effect.Description.GlobalVariableCount; i++)
{
EffectVariable var = effect.GetVariableByIndex(i);
if (var.GetVariableType().Description.TypeName == "Texture2D")
{
EffectResourceVariable rv = var.AsResource();
if (rv.Description.Semantic == "INITIAL")
{
this.initialTextureVariables.Add(rv);
}
if (rv.Description.Semantic == "PREVIOUS")
{
this.previousTextureVariables.Add(rv);
}
if (rv.Description.Semantic == "DEPTHTEXTURE")
{
this.depthTextureVariables.Add(rv);
}
//If semantic starts with passresult
if (rv.Description.Semantic.StartsWith("PASSRESULT"))
{
string sidx = rv.Description.Semantic.Substring(10);
int pridx;
if (int.TryParse(sidx, out pridx))
{
if (pridx < maxPassCount)
{
if (this.passResultVariableArray[pridx] == null)
{
this.passResultVariableArray[pridx] = new List <EffectResourceVariable>();
}
this.passResultVariableArray[pridx].Add(rv);
}
}
}
}
}
}
public void ApplyGlobal(DX11ShaderInstance instance)
{
//this.globalsettings = settings;
this.rendervariables.Apply(instance, this.globalsettings);
this.shaderpins.Preprocess(instance);
}
public TextureArraySetSlice(DX11RenderContext context)
{
this.context = context;
this.shader = ShaderUtils.GetShader(context, "SetSlice");
this.quad = context.Primitives.FullScreenQuad;
this.quad.ValidateLayout(this.shader.GetPass(0), out this.layout);
}
public void Apply(DX11ShaderInstance instance, DX11RenderSettings settings)
{
foreach (string rv in this.variables.Keys)
{
IRenderVariable var = this.variables[rv];
var.Apply(instance, settings);
}
}
public void Dispose()
{
if (this.shaderInstance != null)
{
this.shaderInstance.Dispose();
this.shaderInstance = null;
}
}
public override void Apply(DX11ShaderInstance shaderinstance, DX11RenderSettings settings)
{
Vector2 v = new Vector2(settings.RenderWidth, settings.RenderHeight);
v.X = 1.0f / v.X;
v.Y = 1.0f / v.Y;
shaderinstance.SetByName(this.Name, v);
}
public override void SetVariable(DX11ShaderInstance shaderinstance, int slice)
{
ISpread <T> f = this.pin[slice];
for (int i = 0; i < array.Length; i++)
{
array[i] = f[i];
}
this.UpdateShaderValue(shaderinstance);
}
public void Update(DX11RenderContext context)
{
if (shaderSample == null)
{
shaderSample = new DX11ShaderInstance(context, effectSample);
shaderLoad = new DX11ShaderInstance(context, effectLoad);
}
DX11ShaderInstance instance = this.pixelCoords[0] ? shaderLoad : shaderSample;
if (this.mipLevel.SliceCount > 1)
{
instance.SelectTechnique("ConstantLevel");
}
else
{
instance.SelectTechnique("DynamicLevel");
}
int totalCount;
if (this.mipLevel.SliceCount > 1)
{
totalCount = SpreadUtils.SpreadMax(this.coordinates, this.mipLevel);
instance.SetByName("UvCount", this.coordinates.SliceCount);
instance.SetByName("LevelCount", this.mipLevel.SliceCount);
}
else
{
totalCount = this.coordinates.SliceCount;
instance.SetByName("MipLevel", this.mipLevel[0]);
}
this.coordinateBuffer = this.coordinateBuffer.GetOrResize(context.Device, this.coordinates.SliceCount, 8);
this.levelBuffer = this.levelBuffer.GetOrResize(context.Device, this.mipLevel.SliceCount, 4);
this.writeBuffer = this.writeBuffer.GetOrResize(context.Device, totalCount, 16);
this.readbackBuffer = this.readbackBuffer.GetOrResize(context.Device, totalCount, 16);
instance.SetByName("TotalCount", totalCount);
instance.SetByName("uvBuffer", coordinateBuffer.SRV);
if (this.mipLevel.SliceCount > 1)
{
instance.SetByName("uvLevelBuffer", levelBuffer.SRV);
}
instance.SetByName("inputTexture", this.textureInput[0][context].SRV);
instance.SetByName("OutputBuffer", writeBuffer.UAV);
instance.ApplyPass(0);
context.CurrentDeviceContext.CopyResource(this.writeBuffer.Buffer, this.readbackBuffer.Buffer);
}
protected override void ApplyVariable(string name, DX11ShaderInstance instance)
{
if (this.ResetCounter)
{
instance.SetByName(name, this.Data.UAV, this.Counter);
}
else
{
instance.SetByName(name, this.Data.UAV);
}
}
public override void SetVariable(DX11ShaderInstance shaderinstance, int slice)
{
if (this.pin.IsConnected)
{
shaderinstance.SetByName(this.Name, this.GetSRV(shaderinstance.RenderContext, slice));
}
else
{
shaderinstance.SetByName(this.Name, this.GetDefaultSRV(shaderinstance.RenderContext));
}
}
private ShaderResourceView GetView(DX11ShaderInstance shaderinstance, int slice)
{
if (this.pin.IsConnected)
{
return(this.GetSRV(shaderinstance.RenderContext, slice));
}
else
{
return(this.GetDefaultSRV(shaderinstance.RenderContext));
}
}
/// <summary>
/// Try to find a custom semantic to a particular instance
/// </summary>
/// <param name="instance">Shader instance</param>
/// <param name="variables">Custom variable list</param>
/// <returns>If not mandatory, always return true, else, return true only if bound</returns>
public bool Apply(DX11ShaderInstance instance, List <IDX11CustomRenderVariable> variables)
{
foreach (IDX11CustomRenderVariable variable in variables)
{
if (variable.TypeName == this.TypeName && variable.Semantic == this.Semantic)
{
this.ApplyVariable(variable.Name, instance);
return(true);
}
}
//Not bound
return(!this.Mandatory);
}
public override Action <int> CreateAction(DX11ShaderInstance instance)
{
var sv = instance.Effect.GetVariableByName(this.Name).AsVector();
return((i) =>
{
Vector4 c = new Vector4((float)colorPtr[(i * 4) % colorCnt],
(float)colorPtr[(i * 4 + 1) % colorCnt],
(float)colorPtr[(i * 4 + 2) % colorCnt],
(float)colorPtr[(i * 4 + 3) % colorCnt]);
sv.Set(c);
});
}
public override Action <int> CreateAction(DX11ShaderInstance instance)
{
var sv = instance.Effect.GetVariableByName(this.Name).AsResource();
List <EffectVectorVariable> sizeOfVar = new List <EffectVectorVariable>();
List <EffectVectorVariable> invSizeOfVar = new List <EffectVectorVariable>();
List <EffectMatrixVariable> aspectVar = new List <EffectMatrixVariable>();
List <AspectRatioMode> aspectMode = new List <AspectRatioMode>();
for (int i = 0; i < instance.Effect.Description.GlobalVariableCount; i++)
{
var v = instance.Effect.GetVariableByIndex(i);
if (v.GetVariableType().Description.TypeName == "float2" && v.Description.Semantic == "SIZEOF" && v.Reference(this.Name))
{
sizeOfVar.Add(v.AsVector());
}
if (v.GetVariableType().Description.TypeName == "float2" && v.Description.Semantic == "INVSIZEOF" && v.Reference(this.Name))
{
invSizeOfVar.Add(v.AsVector());
}
if (v.GetVariableType().Description.TypeName == "float4x4" && v.Description.Semantic == "ASPECTOF" && v.Reference(this.Name))
{
aspectVar.Add(v.AsMatrix());
aspectMode.Add(v.AspectMode());
}
}
if (sizeOfVar.Count == 0 && invSizeOfVar.Count == 0 && aspectMode.Count == 0)
{
return((i) => { sv.SetResource(this.GetResource(instance.RenderContext, i).SRV); });
}
else
{
return((i) =>
{
var resource = this.GetResource(instance.RenderContext, i);
sv.SetResource(resource.SRV);
for (int j = 0; j < sizeOfVar.Count; j++)
{
sizeOfVar[j].Set(new Vector2(resource.Width, resource.Height));
}
for (int j = 0; j < invSizeOfVar.Count; j++)
{
invSizeOfVar[j].Set(new Vector2(1.0f / resource.Width, 1.0f / resource.Height));
}
for (int j = 0; j < aspectVar.Count; j++)
{
aspectVar[j].SetMatrix(AspectUtils.AspectMatrix(new Vector2(resource.Width, resource.Height), aspectMode[i]));
}
});
}
}
public override void SetVariable(DX11ShaderInstance shaderinstance, int slice)
{
if (this.pin.IsConnected)
{
using (var state = SamplerState.FromDescription(shaderinstance.RenderContext.Device, this.pin[slice]))
{
shaderinstance.SetByName(this.Name, state);
}
}
else
{
shaderinstance.Effect.GetVariableByName(this.Name).AsSampler().UndoSetSamplerState(0);
}
}
protected override void UpdateShaderValue(DX11ShaderInstance shaderinstance)
{
DataStream ds = new DataStream(4 * this.array.Length * sizeof(float), true, true);
for (int i = 0; i < this.array.Length; i++)
{
ds.Write <Vector3>(this.array[i]);
ds.Write(0.0f);
}
ds.Position = 0;
shaderinstance.Effect.GetVariableByName(this.Name).SetRawValue(ds, (int)ds.Length);
ds.Dispose();
}
public override void SetVariable(DX11ShaderInstance shaderinstance, int slice)
{
if (!uvspace)
{
shaderinstance.SetByName(this.Name, this.pin[slice]);
}
else
{
Matrix m = pin[slice];
//m.M42 = -m.M42;
m = Matrix.Translation(-0.5f, -0.5f, 0.0f) * m * Matrix.Translation(0.5f, 0.5f, 0.0f);
shaderinstance.SetByName(this.Name, m);
}
}
public ShaderDeviceData(DX11RenderContext context)
{
string basepath = "VVVV.DX11.Nodes.effects.DrawFullScreen.fx";
using (DX11Effect effect = DX11Effect.FromResource(Assembly.GetExecutingAssembly(), basepath))
{
shaderInstance = new DX11ShaderInstance(context, effect);
inputTextureVariable = shaderInstance.Effect.GetVariableBySemantic("INPUTTEXTURE").AsResource();
colorVariable = shaderInstance.Effect.GetVariableBySemantic("COLOR").AsVector();
samplerVariable = shaderInstance.Effect.GetVariableBySemantic("TEXTURESAMPLER").AsSampler();
texTransformVariable = shaderInstance.Effect.GetVariableBySemantic("TEXTUREMATRIX").AsMatrix();
pass = shaderInstance.CurrentTechnique.GetPassByIndex(0);
}
}
private ShaderResourceView[] GetViews(DX11ShaderInstance shaderinstance, int slice)
{
ShaderResourceView[] data = new ShaderResourceView[array.Length];
for (int i = 0; i < array.Length; i++)
{
try
{
data[i] = this.GetSRV(shaderinstance, slice, i);
}
catch
{
data[i] = null;
}
}
return(data);
}
public override Action <DX11RenderSettings> CreateAction(DX11ShaderInstance shader)
{
var sv = shader.Effect.GetVariableByName(this.Name).AsResource();
return((s) =>
{
if (shader.RenderContext.RenderTargetStack.Current.ReadonlyDepth)
{
var ds = shader.RenderContext.RenderTargetStack.Current.DepthStencil;
sv.SetResource(((IDX11ReadableResource)ds).SRV);
}
else
{
sv.SetResource(null);
}
});
}
public override void SetVariable(DX11ShaderInstance shaderinstance, int slice)
{
//ISpread<U> f = this.pin[slice];
ShaderResourceView[] data = new ShaderResourceView[array.Length];
for (int i = 0; i < array.Length; i++)
{
try
{
data[i] = this.GetSRV(shaderinstance, slice, i);
}
catch
{
data[i] = null;
}
}
shaderinstance.SetByName(this.Name, data);
}
