public DX11ShaderData(DX11RenderContext context, DX11Effect effect)
{
this.context = context;
this.passid = 0;
this.techid = 0;
this.SetEffect(effect);
}
private void HandleConfigDefinesChangeOnStartup(IDiffSpread <string> spread)
{
if (FConfigShader[0] != "" && !configWritten)
{
DX11ShaderInclude FIncludeHandler = new DX11ShaderInclude();
List <ShaderMacro> sms = new List <ShaderMacro>();
if (FConfigDefines[0] != "")
{
string[] defines = FConfigDefines[0].Split(",".ToCharArray());
for (int i = 0; i < defines.Length; i++)
{
try
{
string[] s = defines[i].Split("=".ToCharArray());
if (s.Length == 2)
{
ShaderMacro sm = new ShaderMacro();
sm.Name = s[0];
sm.Value = s[1];
sms.Add(sm);
}
}
catch
{
}
}
}
FShader = DX11Effect.FromString(FConfigShader[0], FIncludeHandler, sms.ToArray());
this.SetShader(FShader, !ShaderCreatedByConfig);
ShaderCreatedByConfig = true;
}
}
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 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();
}
}
}
}
void shadernode_WantRecompile(object sender, EventArgs e)
{
IDX11ShaderNodeWrapper wrp = (IDX11ShaderNodeWrapper)sender;
FIncludeHandler.ParentPath = Path.GetDirectoryName(wrp.Source.Filename);
string code = File.ReadAllText(wrp.Source.Filename);
var shader = DX11Effect.FromString(code, FIncludeHandler,wrp.Macros);
wrp.SetShader(shader, false);
}
public void SetShader(DX11Effect shader, bool isnew)
{
if (shader.IsCompiled)
{
this.FShader = shader;
this.varmanager.SetShader(shader);
this.shaderVariableCache.Clear();
this.deviceshaderdata.Dispose();
this.currentEffectOut[0] = shader;
}
//Only set technique if new, otherwise do it on update/evaluate
if (isnew)
{
string defaultenum;
if (shader.IsCompiled)
{
defaultenum = shader.TechniqueNames[0];
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.CreateShaderPins();
}
else
{
defaultenum = "";
this.FHost.UpdateEnum(this.TechniqueEnumId, "", new string[0]);
}
//Create Technique enum pin
/*InputAttribute inAttr = new InputAttribute("Technique");
* inAttr.EnumName = this.TechniqueEnumId;
* inAttr.DefaultEnumEntry = defaultenum;
* inAttr.Order = 1000;
* this.FInTechnique = this.FFactory.CreateDiffSpread<EnumEntry>(inAttr);
*
* this.FoutCS.AssignFrom(this.varmanager.GetCustomData());*/
if (shader.TechniqueNames != null)
{
this.techniqueindex = Array.IndexOf(shader.TechniqueNames, FInTechnique[0].Name);
this.techniquechanged = true;
}
}
else
{
if (shader.IsCompiled)
{
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.UpdateShaderPins();
this.FoutCS.AssignFrom(this.varmanager.GetCustomData());
}
}
this.FInvalidate = true;
}
private void HandleConfigShaderChangeOnStartup(IDiffSpread <string> spread)
{
if (FConfigShader[0] != "" && !configWritten)
{
DX11ShaderInclude FIncludeHandler = new DX11ShaderInclude();
List <ShaderMacro> sms = new List <ShaderMacro>();
FShader = DX11Effect.FromString(FConfigShader[0], FIncludeHandler, sms.ToArray());
this.SetShader(FShader, true);
ShaderCreatedByConfig = true;
}
}
private void ParseErrors(string e, FXProject project, DX11Effect shader)
{
string filePath = project.LocalPath;
var compilerResults = ShaderCompilerErrorParser.ParseCompilerResult(e, project.LocalPath, filePath);
//Add some extra error from reflection
if (shader.IsCompiled)
{
compilerResults.Errors.AddRange(this.VerifyShader(project.LocalPath, shader).ToArray());
}
project.CompilerResults = compilerResults;
}
public override void Initialize()
{
base.Initialize();
var effect = DX11Effect.CompileFromString(@"
struct VS_IN
{
float4 PosO : POSITION;
float2 TexCd : TEXCOORD0;
};
struct vs2ps
{
float4 PosWVP: SV_POSITION;
float2 TexCd: TEXCOORD0;
};
cbuffer cbTest : register(b0)
{
float4 offset;
};
Texture2D tex;
SamplerState linSamp
{
Filter = MIN_MAG_MIP_LINEAR;
AddressU = Clamp;
AddressV = Clamp;
};
vs2ps VS(VS_IN input)
{
vs2ps Out = (vs2ps)0;
Out.PosWVP =input.PosO + offset;
Out.TexCd = input.TexCd + tex.Load(int3(0,0,0));
return Out;
}
technique10 Render
{
pass P0
{
SetVertexShader( CompileShader( vs_4_0, VS() ) );
}
}");
this.shader = new EffectInstance(this.Device, effect);
}
public override void SetShader(DX11Effect shader, bool isnew, string fileName)
{
FOutPath.SliceCount = 1;
FOutPath[0] = fileName;
if (shader.IsCompiled)
{
this.FShader = shader;
this.varmanager.SetShader(shader);
this.shaderVariableCache.Clear();
this.deviceshaderdata.Dispose();
this.currentEffectOut[0] = shader;
}
//Only set technique if new, otherwise do it on update/evaluate
if (isnew)
{
string defaultenum;
if (shader.IsCompiled)
{
defaultenum = shader.TechniqueNames[0];
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.CreateShaderPins();
}
else
{
defaultenum = "";
this.FHost.UpdateEnum(this.TechniqueEnumId, "", new string[0]);
}
//Create Technique enum pin
InputAttribute inAttr = new InputAttribute("Technique");
inAttr.EnumName = this.TechniqueEnumId;
inAttr.DefaultEnumEntry = defaultenum;
inAttr.Order = 1000;
this.FInTechnique = this.FFactory.CreateDiffSpread <EnumEntry>(inAttr);
this.FoutCS.AssignFrom(this.varmanager.GetCustomData());
}
else
{
if (shader.IsCompiled)
{
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.UpdateShaderPins();
this.FoutCS.AssignFrom(this.varmanager.GetCustomData());
}
}
this.FInvalidate = true;
}
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);
}
}
public int GetPreferredTechnique(DX11Effect shader)
{
string[] techniqueNames = shader.TechniqueNames;
foreach (string pref in this.PreferredTechniques)
{
for (int i = 0; i < techniqueNames.Length; ++i)
{
if (techniqueNames[i].ToLower() == pref)
{
return(i);
}
}
}
return(-1);
}
public bool HasDynamicPins(DX11Effect shader)
{
if (shader?.DefaultEffect == null)
{
return(false);
}
for (int i = 0; i < shader.DefaultEffect.Description.GlobalVariableCount; i++)
{
EffectVariable var = shader.DefaultEffect.GetVariableByIndex(i);
if (ShaderPinFactory.IsShaderPin(var))
{
return(true);
}
}
return(false);
}
public override void SetShader(DX11Effect shader, bool isnew, string fileName)
{
FOutPath.SliceCount = 1;
FOutPath[0] = fileName;
if (isnew)
{
this.FShader = shader;
}
if (shader.IsCompiled)
{
this.FShader = shader;
this.varmanager.SetShader(shader);
}
//Only set technique if new, otherwise do it on update/evaluate
if (isnew)
{
string defaultenum;
if (shader.IsCompiled)
{
defaultenum = shader.TechniqueNames[0];
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.CreateShaderPins();
}
else
{
defaultenum = "";
this.FHost.UpdateEnum(this.TechniqueEnumId, "", new string[0]);
}
}
else
{
if (shader.IsCompiled)
{
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.UpdateShaderPins();
}
}
this.shaderupdated = true;
this.FInvalidate = true;
}
protected override bool CreateNode(INodeInfo nodeInfo, IInternalPluginHost pluginHost)
{
if (nodeInfo.Type != NodeType.Plugin)
{
return(false);
}
//get the code of the FXProject associated with the nodeinfos filename
//effectHost.SetEffect(nodeInfo.Filename, project.Code);
//compile shader
var shader = DX11Effect.FromByteCode(nodeInfo.Filename);
//create or update plugin
if (pluginHost.Plugin == null)
{
//IPluginBase plug = this.FDotNetFactory.CreatePluginCustom(nodeInfo, pluginHost as IPluginHost2, typeof(DX11ShaderNode));
nodeInfo.AutoEvaluate = false;
nodeInfo.Arguments = typeof(T).ToString();
var pluginContainer = new PluginContainer(pluginHost, FIORegistry, FParentContainer, FNodeInfoFactory, FDotNetFactory, typeof(T), nodeInfo);
pluginHost.Plugin = pluginContainer;
FPluginContainers[pluginContainer.PluginBase] = pluginContainer;
IDX11ShaderNodeWrapper shaderNode = pluginContainer.PluginBase as IDX11ShaderNodeWrapper;
shaderNode.SetShader(shader, true, nodeInfo.Filename);
if (this.PluginCreated != null)
{
this.PluginCreated(pluginContainer, pluginHost);
}
}
else
{
PluginContainer container = pluginHost.Plugin as PluginContainer;
var shaderNode = container.PluginBase as IDX11ShaderNodeWrapper;
shaderNode.SetShader(shader, false, nodeInfo.Filename);
}
return(true);
}
public void Update(IPluginIO pin, DX11RenderContext context)
{
Device device = context.Device;
DeviceContext ctx = context.CurrentDeviceContext;
if (!this.FOutPointcloudBuffer[0].Contains(context) || !this.FOutIndexBuffer[0].Contains(context) || this.FInEleCount.IsChanged)
{
this.FOutPointcloudBuffer[0].Dispose(context);
this.FOutIndexBuffer[0].Dispose(context);
DX11RWStructuredBuffer pcBuffer = new DX11RWStructuredBuffer(device, FInEleCount[0], FInStride[0], eDX11BufferMode.Counter);
DX11RWStructuredBuffer idBuffer = new DX11RWStructuredBuffer(device, FInEleCount[0], 4, eDX11BufferMode.Counter);
this.FOutPointcloudBuffer[0][context] = pcBuffer;
this.FOutIndexBuffer[0][context] = idBuffer;
}
// clear offsetbuffer
int[] mask = new int[4] {
-1, -1, -1, -1
};
ctx.ClearUnorderedAccessView(FOutIndexBuffer[0][context].UAV, mask);
// load shader
if (this.shader == null)
{
string basepath = "RingBufferIndexing.effects.RingBufferIndexing.fx";
DX11Effect effect = DX11Effect.FromResource(Assembly.GetExecutingAssembly(), basepath);
this.shader = new DX11ShaderInstance(context, effect);
}
if (this.FInPointcloudBuffer.PluginIO.IsConnected /* && currentFrame != FHDEHost.FrameTime*/)
{
currentFrame = FHDEHost.FrameTime; // prevents to execute this a second time
shader.SelectTechnique("BuildHash");
shader.SetBySemantic("POINTCLOUDBUFFERIN", FInPointcloudBuffer[0][context].SRV);
shader.SetBySemantic("POINTCLOUDBUFFEROUT", FOutPointcloudBuffer[0][context].UAV, 0);
shader.SetBySemantic("INDEXBUFFER", FOutIndexBuffer[0][context].UAV);
shader.ApplyPass(0);
ctx.Dispatch((FInEleCount[0] + 63) / 64, 1, 1);
context.CleanUp();
context.CleanUpCS();
}
}
public void Update(IPluginIO pin, DX11RenderContext context)
{
Device device = context.Device;
DeviceContext ctx = context.CurrentDeviceContext;
if (!this.FOutLinkBuffer[0].Contains(context) || !this.FOutOffsetBuffer[0].Contains(context) || FInGridcellCount.IsChanged)
{
this.FOutLinkBuffer[0].Dispose(context);
this.FOutOffsetBuffer[0].Dispose(context);
DX11RWStructuredBuffer lb = new DX11RWStructuredBuffer(device, FInEleCount[0], 8, eDX11BufferMode.Counter);
DX11RWStructuredBuffer ob = new DX11RWStructuredBuffer(device, FInGridcellCount[0] * FInGridcellCount[0] * FInGridcellCount[0], 4, eDX11BufferMode.Counter);
this.FOutLinkBuffer[0][context] = lb;
this.FOutOffsetBuffer[0][context] = ob;
}
// clear offsetbuffer
int[] mask = new int[4] {
-1, -1, -1, -1
};
ctx.ClearUnorderedAccessView(FOutOffsetBuffer[0][context].UAV, mask);
// load shader
if (this.shader == null)
{
string basepath = "LinkedList.effects.LinkedList.fx";
DX11Effect effect = DX11Effect.FromResource(Assembly.GetExecutingAssembly(), basepath);
this.shader = new DX11ShaderInstance(context, effect);
}
if (this.FInPcBuffer.PluginIO.IsConnected)
{
shader.SelectTechnique("BuildHash");
shader.SetBySemantic("POINTCLOUDBUFFER", FInPcBuffer[0][context].SRV);
shader.SetBySemantic("POINTTRANSFORM", FInTransform[0]);
shader.SetBySemantic("RWLINKBUFFER", FOutLinkBuffer[0][context].UAV, 0);
shader.SetBySemantic("RWOFFSETBUFFER", FOutOffsetBuffer[0][context].UAV);
shader.SetBySemantic("GRIDCELLSIZE", FInGridcellCount[0]);
shader.ApplyPass(0);
ctx.Dispatch((FInEleCount[0] + 63) / 64, 1, 1);
context.CleanUp();
context.CleanUpCS();
}
}
public SolidColorTransformed(DX11RenderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
this.context = context;
using (var cef = DX11Effect.FromResource(Assembly.GetExecutingAssembly(), "FeralTic.Effects.TransformColor.fx"))
{
this.effect = new Effect(context.Device, cef.ByteCode);
this.pass = this.effect.GetTechniqueByIndex(0).GetPassByIndex(0);
this.viewProjVariable = this.effect.GetVariableByName("tVP").AsMatrix();
this.worldVariable = this.effect.GetVariableByName("tW").AsMatrix();
this.colorVariable = this.effect.GetVariableByName("objectColor").AsVector();
}
}
public override void SetShader(DX11Effect shader, bool isnew)
{
this.FShader = shader;
this.varmanager.SetShader(shader);
//Only set technique if new, otherwise do it on update/evaluate
if (isnew)
{
string defaultenum;
if (shader.IsCompiled)
{
defaultenum = shader.TechniqueNames[0];
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.CreateShaderPins();
}
else
{
defaultenum = "";
this.FHost.UpdateEnum(this.TechniqueEnumId, "", new string[0]);
}
//Create Technique enum pin
InputAttribute inAttr = new InputAttribute("Technique");
inAttr.EnumName = this.TechniqueEnumId;
inAttr.DefaultEnumEntry = defaultenum;
inAttr.Order = 1000;
this.FInTechnique = this.FFactory.CreateDiffSpread <EnumEntry>(inAttr);
}
else
{
if (shader.IsCompiled)
{
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.UpdateShaderPins();
}
}
this.shaderupdated = true;
this.FInvalidate = true;
}
public override void SetShader(DX11Effect shader, bool isnew)
{
if (shader.IsCompiled)
{
this.FShader = shader;
this.varmanager.SetShader(shader);
this.varmanager.RebuildTextureCache();
this.varmanager.RebuildPassCache(tid);
//this.varmanager.RebuildPassCache(0);
}
//Only set technique if new, otherwise do it on update/evaluate
if (isnew)
{
string defaultenum;
if (shader.IsCompiled)
{
defaultenum = shader.TechniqueNames[0];
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.CreateShaderPins();
}
else
{
defaultenum = "";
this.FHost.UpdateEnum(this.TechniqueEnumId, "", new string[0]);
}
}
else
{
if (shader.IsCompiled)
{
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.UpdateShaderPins();
}
}
this.shaderupdated = true;
this.FInvalidate = true;
}
public void Update(IPluginIO pin, DX11RenderContext context)
{
if (quadshader == null)
{
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);
}
}
if (this.spmax > 0)
{
if (!this.FOutLayer[0].Contains(context))
{
this.FOutLayer[0][context] = new DX11Layer();
this.FOutLayer[0][context].Render = this.Render;
}
}
}
public abstract void SetShader(DX11Effect shader, bool isnew, string fileName);
protected virtual List <CompilerError> VerifyShader(string file, DX11Effect effect)
{
return(new List <CompilerError>());
}
protected override bool CreateNode(INodeInfo nodeInfo, IInternalPluginHost pluginHost)
{
if (nodeInfo.Type != NodeType.Dynamic)
{
return(false);
}
var project = nodeInfo.UserData as FXProject;
/*if (!project.IsLoaded)
* project.Load();*/
//compile shader
FIncludeHandler.ParentPath = Path.GetDirectoryName(nodeInfo.Filename);
string code = File.ReadAllText(nodeInfo.Filename);
DX11Effect shader;
//create or update plugin
if (pluginHost.Plugin == null)
{
nodeInfo.AutoEvaluate = false;
nodeInfo.Arguments = typeof(T).ToString();
var pluginContainer = new PluginContainer(pluginHost, FIORegistry, FParentContainer, FNodeInfoFactory, FDotNetFactory, typeof(T), nodeInfo);
pluginHost.Plugin = pluginContainer;
FPluginContainers[pluginContainer.PluginBase] = pluginContainer;
IDX11ShaderNodeWrapper shaderNode = pluginContainer.PluginBase as IDX11ShaderNodeWrapper;
shaderNode.Source = nodeInfo;
shaderNode.WantRecompile += new EventHandler(shadernode_WantRecompile);
shader = DX11Effect.FromString(code, FIncludeHandler, shaderNode.Macros);
shaderNode.SetShader(shader, true, nodeInfo.Filename);
if (this.PluginCreated != null)
{
this.PluginCreated(pluginContainer, pluginHost);
}
}
else
{
PluginContainer container = pluginHost.Plugin as PluginContainer;
var shaderNode = container.PluginBase as IDX11ShaderNodeWrapper;
shader = DX11Effect.FromString(code, FIncludeHandler, shaderNode.Macros);
shaderNode.SetShader(shader, false, nodeInfo.Filename);
}
//now the effect is compiled in vvvv and we can access the errors
string e = shader.ErrorMessage;//effectHost.GetErrors();
if (string.IsNullOrEmpty(e))
{
e = "";
}
this.ParseErrors(e, project, shader);
//and the input pins
string f = "";// effectHost.GetParameterDescription();
if (string.IsNullOrEmpty(f))
{
f = "";
}
project.ParameterDescription = f;
return(true);
}
private void ParseErrors(string e, FXProject project, DX11Effect shader)
{
var compilerResults = new CompilerResults(null);
//now parse errors to CompilerResults
//split errorstring linewise
var errorlines = e.Split(new char[1] {
'\n'
});
foreach (var line in errorlines)
{
string filePath = project.LocalPath;
string eCoords = string.Empty;
int eLine = 0;
int eChar = 0;
string eNumber = string.Empty;
string eText = string.Empty;
bool isWarning = false;
if (string.IsNullOrEmpty(line))
{
continue;
}
//split the line at ": "
//which results in 3 or 4 lines:
//[0] filename (line, character)
//[1] error/warning code
//[2] (optional) erroneous character
//[3] error description
var eItems = line.Split(new string[1] {
": "
}, StringSplitOptions.None);
//extract line/char substring
int start = eItems[0].LastIndexOf('(');
int end = eItems[0].LastIndexOf(')');
if (start > 0)
{
string relativePath = eItems[0].Substring(0, start);
//if this is a path to an include..
if (relativePath != Path.Combine(FHDEHost.ExePath, "memory"))
{
// we need to guess here. shader compiler outputs relative paths.
// we don't know if the include was "local" or <global>
filePath = Path.Combine(Path.GetDirectoryName(project.LocalPath), relativePath);
if (!File.Exists(filePath))
{
string fileName = Path.GetFileName(relativePath);
foreach (var reference in project.References)
{
var referenceFileName = Path.GetFileName((reference as FXReference).ReferencedDocument.LocalPath);
if (referenceFileName.ToLower() == fileName.ToLower())
{
filePath = reference.AssemblyLocation;
}
}
}
}
}
if (start > -1 && end > 0)
{
eCoords = eItems[0].Substring(start + 1, end - start - 1);
var eLineChar = eCoords.Split(new char[1] {
','
});
eLine = Convert.ToInt32(eLineChar[0]);
eChar = Convert.ToInt32(eLineChar[1]);
if (eItems[1].StartsWith("warning"))
{
isWarning = true;
eNumber = eItems[1].Substring(8, 5);
}
else
{
eNumber = eItems[1].Substring(6, 5);
}
if (eItems.Length == 2)
{
isWarning = false;
eNumber = "-1";
eText = eItems[1];
}
else
{
eText = eItems[2];
if (eItems.Length > 3)
{
eText += ": " + eItems[3];
}
}
}
else
{
eText = line;
}
var error = new CompilerError(filePath, eLine, eChar, eNumber, eText);
error.IsWarning = isWarning;
compilerResults.Errors.Add(error);
}
//Add some extra error from reflection
if (shader.IsCompiled)
{
compilerResults.Errors.AddRange(this.VerifyShader(project.LocalPath, shader).ToArray());
}
project.CompilerResults = compilerResults;
}
protected override List <CompilerError> VerifyShader(string file, DX11Effect effect)
{
List <CompilerError> errors = new List <CompilerError>();
if (effect.DefaultEffect.Description.TechniqueCount == 0)
{
errors.Add(new CompilerError(file, 0, 0, "", "Effect Has No techniques"));
return(errors);
}
//Verify techniques
for (int i = 0; i < effect.DefaultEffect.Description.TechniqueCount; i++)
{
EffectTechnique tech = effect.DefaultEffect.GetTechniqueByIndex(i);
if (tech.Description.PassCount == 0)
{
errors.Add(new CompilerError(file, 0, 0, "", "Technique: " + tech.Description.Name + " has no passes"));
return(errors);
}
else
{
for (int p = 0; p < tech.Description.PassCount; p++)
{
EffectPass pass = tech.GetPassByIndex(p);
if (!this.ComputeOrPixelOnly(pass))
{
errors.Add(new CompilerError(file, 0, 0, "", "Technique: " + tech.Description.Name + " : Pass : "******" Must be pixel only or compute only"));
}
else
{
//Manually validate layout for pixelshader
if (this.PixelOnly(pass))
{
EffectShaderVariable ps = pass.PixelShaderDescription.Variable;
int inputcount = ps.GetShaderDescription(0).InputParameterCount;
bool hassvpos = false;
bool hasuv = false;
for (int ip = 0; ip < inputcount; ip++)
{
ShaderParameterDescription sd = ps.GetInputParameterDescription(0, ip);
if (sd.SystemType == SystemValueType.Position)
{
hassvpos = true;
}
if (sd.SemanticName == "TEXCOORD")
{
hasuv = true;
}
}
if (!(hassvpos && hasuv) && inputcount == 2)
{
errors.Add(new CompilerError(file, 0, 0, "", "Technique: " + tech.Description.Name + " : Pass : "******" Must be SV_Position and TEXCOORD0 as input"));
}
}
}
}
}
}
return(errors);
}
public void Evaluate(int SpreadMax)
{
this.shaderupdated = false;
this.spmax = this.CalculateSpreadMax();
if (FShaderCode.IsChanged || FFileName.IsChanged || FInDefines.IsChanged)
{
List <ShaderMacro> sms = new List <ShaderMacro>();
for (int i = 0; i < this.FInDefines.SliceCount; i++)
{
try
{
string[] s = this.FInDefines[i].Split("=".ToCharArray());
if (s.Length == 2)
{
ShaderMacro sm = new ShaderMacro();
sm.Name = s[0];
sm.Value = s[1];
sms.Add(sm);
}
}
catch
{
}
}
DX11ShaderInclude FIncludeHandler = new DX11ShaderInclude();
FIncludeHandler.ParentPath = Path.GetDirectoryName(FFileName[0]);
FShader = DX11Effect.FromString(FShaderCode[0], FIncludeHandler, sms.ToArray());
if (init && !ShaderCreatedByConfig)
{
this.SetShader(FShader, true);
init = false;
}
else
{
this.SetShader(FShader, false);
}
// Write Shadercode & Defines into config -> needed to restore dynamic pins
if (HasDynamicPins(FShader))
{
configWritten = true;
if (FConfigShader[0] != FShaderCode[0])
{
FConfigShader[0] = FShaderCode[0];
FConfigDefines[0] = "";
for (int i = 0; i < FInDefines.SliceCount; i++)
{
if (i != 0)
{
FConfigDefines[0] += ",";
}
FConfigDefines[0] += this.FInDefines[i];
}
}
}
else
{
if (FConfigShader[0] != "")
{
FConfigShader[0] = "";
FConfigDefines[0] = "";
}
}
}
if (FShader.TechniqueNames != null && this.FInTechnique.IsChanged && FInTechnique.SliceCount > 0)
{
this.techniqueindex = Array.IndexOf(FShader.TechniqueNames, FInTechnique[0].Name);
this.techniquechanged = true;
}
float *src;
//Cache world pointer
this.FInWorld.GetMatrixPointer(out this.mworldcount, out src);
this.mworld = (Matrix *)src;
this.FOutLayer.SliceCount = 1;
if (this.FOutLayer[0] == null)
{
this.FOutLayer[0] = new DX11Resource <DX11Layer>();
}
if (this.FInvalidate)
{
if (this.FShader.IsCompiled)
{
this.FOutCompiled[0] = true;
this.FOutTechniqueValid.SliceCount = this.FShader.TechniqueValids.Length;
for (int i = 0; i < this.FShader.TechniqueValids.Length; i++)
{
this.FOutTechniqueValid[i] = this.FShader.TechniqueValids[i];
}
}
else
{
this.FOutCompiled[0] = false;
this.FOutTechniqueValid.SliceCount = 0;
}
this.FInvalidate = false;
}
if (this.FOutQueryable[0] == null)
{
this.FOutQueryable[0] = this;
}
}
public void RecalcShader(bool isNew)
{
var declarations = "";
var pscode = @"
float4 col = float4(1, 1, 1, 1);
return col;";
if (FShaderProvider.SliceCount > 0 && FShaderProvider[0] != null)
{
this.traverseResult = FShaderProvider[0].Traverse();
declarations = string.Join(@"
", traverseResult.GlobalVars.Select(gv => gv.Value.ToString()).Concat(traverseResult.FunctionDeclarations.Values));
pscode = string.Join(@"
", traverseResult.LocalDeclarations.Values) + $@"
return {traverseResult.LocalDeclarations[FShaderProvider[0]].Identifier};";
;
}
var effectText = declarations +
@"
SamplerState linearSampler: IMMUTABLE
{
Filter = MIN_MAG_MIP_LINEAR;
AddressU = Clamp;
AddressV = Clamp;
};
cbuffer cbPerDraw : register(b0)
{
float4x4 tVP : LAYERVIEWPROJECTION;
};
cbuffer cbPerObj : register(b1)
{
float4x4 tW : WORLD;
};
struct VS_IN
{
float4 PosO : POSITION;
float4 TexCd : TEXCOORD0;
};
struct vs2ps
{
float4 PosWVP: SV_Position;
float2 TexCd: TEXCOORD0;
};
vs2ps VS(VS_IN input)
{
vs2ps output;
output.PosWVP = mul(input.PosO, mul(tW, tVP));
output.TexCd = input.TexCd.xy;
return output;
}
float4 PS(vs2ps In): SV_Target
{
"
+ pscode +
@"
}
technique10 Patched
{
pass P0
{
SetVertexShader(CompileShader(vs_4_0, VS()));
SetPixelShader(CompileShader(ps_4_0, PS()));
}
}";
FCode.SliceCount = 1;
FCode[0] = effectText;
SetShader(DX11Effect.FromString(effectText), isNew, "");
}
public void Update(DX11RenderContext context)
{
for (int i = 0; i < framePool.Count; i++)
{
framePool[i].UnLock();
}
framePool.Clear();
if (this.textureOutput.SliceCount == 0)
{
return;
}
//
//Compile shader if necessary
if (shader == null)
{
using (DX11Effect effect = DX11Effect.FromResource(Assembly.GetExecutingAssembly(), Consts.EffectPath + ".ExtractChannel.fx"))
{
shader = new DX11ShaderInstance(context, effect);
}
}
if (shaderExpand == null)
{
using (DX11Effect effect = DX11Effect.FromResource(Assembly.GetExecutingAssembly(), Consts.EffectPath + ".ExtractChannelExpand.fx"))
{
shaderExpand = new DX11ShaderInstance(context, effect);
}
}
for (int i = 0; i < this.textureOutput.SliceCount; i++)
{
if (this.textureInput[i] == null)
{
this.SetDefault(context, i);
}
else if (this.textureInput[i].Contains(context))
{
var instance = this.singleChannelOut[i] ? shader : shaderExpand;
var input = this.textureInput[i][context];
string prefix = "Float";
var inputFormat = input.SRV.Description.Format;
inputFormat = inputFormat.DefaultOutputForCompressed();
if (inputFormat.IsSignedInt())
{
prefix = "UInt";
}
if (inputFormat.IsUnsignedInt())
{
prefix = "Int";
}
prefix += this.channel[i].ToString();
instance.SelectTechnique(prefix);
instance.SetByName("InputTexture", input.SRV);
var outputFormat = inputFormat;
if (this.singleChannelOut[i])
{
var singleFormat = outputFormat.GetSingleChannelEquivalent();
if (singleFormat == SlimDX.DXGI.Format.Unknown)
{
this.message[i] = "Could not find a single channel format suitable for : " + outputFormat.ToString();
this.SetDefault(context, i);
continue;
}
else
{
outputFormat = singleFormat;
}
}
var output = context.ResourcePool.LockRenderTarget(input.Width, input.Height, outputFormat, false, 1, false);
context.RenderTargetStack.Push(output.Element);
context.Primitives.ApplyFullTriVSPosition();
instance.ApplyPass(0);
context.CurrentDeviceContext.Draw(3, 0);
context.RenderTargetStack.Pop();
this.framePool.Add(output);
this.textureOutput[i][context] = output.Element;
this.message[i] = "ok";
}
else
{
this.SetDefault(context, i);
}
}
if (this.BeginQuery != null)
{
this.BeginQuery(context);
}
if (this.EndQuery != null)
{
this.EndQuery(context);
}
}
public void SetShader(DX11Effect shader)
{
this.shader = shader;
}
