public void Render(SharpGL.OpenGL gl, ShaderWrapper shader)
{
m_vertexBuffer.Bind(gl);
// TODO: CENTRE TUBES
var rotation = Matrix4.CreateRotationY(MathEx.PiOver2);
shader.SetModelMatrix(rotation);
m_xCylinder.Render(gl, shader);
rotation = Matrix4.CreateRotationX(-MathEx.PiOver2);
shader.SetModelMatrix(rotation);
m_yCylinder.Render(gl, shader);
rotation = Matrix4.CreateRotationZ(MathEx.PiOver2);
shader.SetModelMatrix(rotation);
m_zCylinder.Render(gl, shader);
m_vertexBuffer.Unbind(gl);
}
public MeshRenderer(ShaderWrapper shader, Mesh mesh) : base(shader, mesh)
{
}
public Shader CreateVertexShader(bool cg, string source, string entry, bool required)
{
try
{
ShaderWrapper sw = new ShaderWrapper();
if (cg)
{
var cgc = new CGC();
var results = cgc.Run(source, entry, "hlslv", true);
source = results.Code;
entry = "main";
if (!results.Succeeded)
{
if (required)
{
throw new InvalidOperationException(results.Errors);
}
else
{
return(new Shader(this, null, false));
}
}
sw.MapCodeToNative = results.MapCodeToNative;
sw.MapNativeToCode = results.MapNativeToCode;
}
string errors = null;
d3d9.ShaderBytecode bytecode = null;
try
{
//cgc can create shaders that will need backwards compatibility...
string profile = "vs_1_1";
if (cg)
{
profile = "vs_3_0"; //todo - smarter logic somehow
}
bytecode = d3d9.ShaderBytecode.Compile(source, null, null, entry, profile, ShaderFlags.EnableBackwardsCompatibility, out errors);
}
catch (Exception ex)
{
throw new InvalidOperationException("Error compiling shader: " + errors, ex);
}
sw.vs = new VertexShader(dev, bytecode);
sw.bytecode = bytecode;
Shader s = new Shader(this, sw, true);
sw.IGLShader = s;
return(s);
}
catch
{
if (required)
{
throw;
}
else
{
return(new Shader(this, null, false));
}
}
}
public Shader CreateFragmentShader(bool cg, string source, string entry, bool required)
{
try
{
ShaderWrapper sw = new ShaderWrapper();
if (cg)
{
var cgc = new CGC();
var results = cgc.Run(source, entry, "hlslf", true);
source = results.Code;
entry = "main";
if (!results.Succeeded)
{
if (required)
{
throw new InvalidOperationException(results.Errors);
}
else
{
return(new Shader(this, null, false));
}
}
sw.MapCodeToNative = results.MapCodeToNative;
sw.MapNativeToCode = results.MapNativeToCode;
}
string errors = null;
d3d9.ShaderBytecode bytecode = null;
try
{
//cgc can create shaders that will need backwards compatibility...
string profile = "ps_1_0";
if (cg)
{
profile = "ps_3_0"; //todo - smarter logic somehow
}
//ShaderFlags.EnableBackwardsCompatibility - used this once upon a time (please leave a note about why)
//
bytecode = d3d9.ShaderBytecode.Compile(source, null, null, entry, profile, ShaderFlags.UseLegacyD3DX9_31Dll, out errors);
}
catch (Exception ex)
{
throw new InvalidOperationException("Error compiling shader: " + errors, ex);
}
sw.ps = new PixelShader(dev, bytecode);
sw.bytecode = bytecode;
Shader s = new Shader(this, sw, true);
sw.IGLShader = s;
return(s);
}
catch
{
if (required)
{
throw;
}
else
{
return(new Shader(this, null, false));
}
}
}
private static void CompileShader(ShaderWrapper shader, Device device)
{
// hack to add includes to list to allow easy reloading after include has changed...
m_CurrentlyProcessedShader = shader;
bool done = false;
while (!done)
{
try
{
var defines = new ShaderMacro[shader.m_Defines.Count];
int counter = 0;
foreach (var define in shader.m_Defines)
{
defines[counter++] = new ShaderMacro(define, "1");
}
switch (shader.m_ShaderType)
{
case ShaderType.PixelShader:
using (var bytecode = ShaderBytecode.CompileFromFile(shader.m_FilePath, shader.m_ShaderEntry, "ps_5_0", ShaderFlags.WarningsAreErrors, EffectFlags.None, defines, m_Include))
shader.m_PixelShader = new PixelShader(device, bytecode);
break;
case ShaderType.ComputeShader:
using (var bytecode = ShaderBytecode.CompileFromFile(shader.m_FilePath, shader.m_ShaderEntry, "cs_5_0", ShaderFlags.WarningsAreErrors, EffectFlags.None, defines, m_Include))
shader.m_ComputeShader = new ComputeShader(device, bytecode);
break;
case ShaderType.GeometryShader:
using (var bytecode = ShaderBytecode.CompileFromFile(shader.m_FilePath, shader.m_ShaderEntry, "gs_5_0", ShaderFlags.WarningsAreErrors, EffectFlags.None, defines, m_Include))
shader.m_GeometryShader = new GeometryShader(device, bytecode);
break;
case ShaderType.VertexShader:
using (var bytecode = ShaderBytecode.CompileFromFile(shader.m_FilePath, shader.m_ShaderEntry, "vs_5_0", ShaderFlags.WarningsAreErrors, EffectFlags.None, defines, m_Include))
{
shader.m_VertexInputSignature = ShaderSignature.GetInputSignature(bytecode);
shader.m_VertexShader = new VertexShader(device, bytecode);
}
break;
}
done = true;
}
catch (Exception e)
{
System.Windows.Forms.MessageBox.Show(e.Message, "Shader compilation error");
}
}
m_CurrentlyProcessedShader = null;
if (m_Shaders.ContainsKey(shader.m_ShaderName))
{
m_Shaders[shader.m_ShaderName] = shader;
}
else
{
m_Shaders.Add(shader.m_ShaderName, shader);
}
}
public void Render(SharpGL.OpenGL gl, ShaderWrapper shader)
{
foreach (var animator in m_animators)
{
var cubie = animator.Cubie;
shader.SetModelMatrix(cubie.GenerateModelMatrix());
var cube = cubie.Highlighted ? HighlightCube : cubie.Cube;
cube.Render(gl, shader);
}
}
public Shader CreateVertexShader(bool cg, string source, string entry, bool required)
{
try
{
ShaderWrapper sw = new ShaderWrapper();
if (cg)
{
var cgc = new CGC();
var results = cgc.Run(source, entry, "hlslv", true);
source = results.Code;
entry = "main";
if (!results.Succeeded)
{
if (required) throw new InvalidOperationException(results.Errors);
else return new Shader(this, null, false);
}
sw.MapCodeToNative = results.MapCodeToNative;
sw.MapNativeToCode = results.MapNativeToCode;
}
string errors = null;
d3d9.ShaderBytecode bytecode = null;
try
{
//cgc can create shaders that will need backwards compatibility...
string profile = "vs_1_1";
if (cg)
profile = "vs_3_0"; //todo - smarter logic somehow
bytecode = d3d9.ShaderBytecode.Compile(source, null, null, entry, profile, ShaderFlags.EnableBackwardsCompatibility, out errors);
}
catch (Exception ex)
{
throw new InvalidOperationException("Error compiling shader: " + errors, ex);
}
sw.vs = new VertexShader(dev, bytecode);
sw.bytecode = bytecode;
Shader s = new Shader(this, sw, true);
sw.IGLShader = s;
return s;
}
catch(Exception ex)
{
if (required)
throw;
var s = new Shader(this, null, false);
s.Errors = ex.ToString();
return s;
}
}
private static void ParseFile(string path)
{
List<ShaderWrapper> localShaders = new List<ShaderWrapper>();
List<Tuple<string, int, int, int>> computeRegisters = new List<Tuple<String, int, int, int>>();
ShaderFile sf = m_AllShaderFiles[GetFileNameFromPath(path)];
sf.m_DirectlyIncludedFiles.Clear();
sf.m_FlattenedFiles.Clear();
using (StreamReader sr = new StreamReader(path))
{
while (!sr.EndOfStream)
{
String line = sr.ReadLine();
Match matchShaderRegex = m_RegexWrapper.shaderRegex.Match(line);
Match matchCbufferRegex = m_RegexWrapper.cbufferRegex.Match(line);
Match matchSamplerRegex = m_RegexWrapper.samplerRegex.Match(line);
Match matchNumThreadsRegex = m_RegexWrapper.numThreadsRegex.Match(line);
Match matchGlobalDefineRegex = m_RegexWrapper.globalDefineRegex.Match(line);
Match matchIncludeRegex = m_RegexWrapper.includeRegex.Match(line);
if (matchIncludeRegex.Success)
{
string includeName = matchIncludeRegex.Groups[1].Value;
sf.m_DirectlyIncludedFiles.Add(includeName);
}
if (matchGlobalDefineRegex.Success)
{
string defineName = matchGlobalDefineRegex.Groups[1].Value;
float value = Single.Parse(matchGlobalDefineRegex.Groups[2].Value, CultureInfo.InvariantCulture);
if (m_GlobalDefineValues.ContainsKey(defineName))
{
m_GlobalDefineValues[defineName] = value;
}
else
{
m_GlobalDefineValues.Add(defineName, value);
}
}
if (matchCbufferRegex.Success)
{
Match globalBufferMatch = m_RegexWrapper.globalBufferRegex.Match(line);
Match registerMatch = m_RegexWrapper.registerRegex.Match(line);
if (!registerMatch.Success)
{
throw new Exception("Unable to find register for constant buffer");
}
int cbufferRegister = Int32.Parse(registerMatch.Groups[1].Value);
// We have a new cbuffer
string cbufferName = matchCbufferRegex.Groups[1].Value;
string cbufferText = "";
while (!sr.EndOfStream)
{
line = sr.ReadLine();
if (line.Contains('{'))
continue;
if (line.Contains('}'))
{
if (m_ConstantBuffers.ContainsKey(cbufferName))
{
m_ConstantBuffers[cbufferName].ParseConstantBuffer(cbufferText, cbufferRegister, globalBufferMatch.Success);
}
else
{
CustomConstantBufferDefinition myNewConstantBuffer =
new CustomConstantBufferDefinition(
cbufferName,
cbufferText,
cbufferRegister,
globalBufferMatch.Success,
path);
m_ConstantBuffers.Add(cbufferName, myNewConstantBuffer);
}
break;
}
cbufferText += line.Trim() + "\n";
}
continue;
}
if (matchShaderRegex.Success)
{
// We have a new shader
string shaderType = matchShaderRegex.Groups[1].Value;
string shaderName = matchShaderRegex.Groups[2].Value;
string shaderEntry = matchShaderRegex.Groups[3].Value;
string shaderDefines = matchShaderRegex.Groups[4].Value;
ShaderType type = ShaderType.PixelShader;
switch (shaderType.ToLower())
{
case "pixel": type = ShaderType.PixelShader;
break;
case "vertex": type = ShaderType.VertexShader;
break;
case "compute": type = ShaderType.ComputeShader;
break;
case "geometry": type = ShaderType.GeometryShader;
break;
}
HashSet<string> defines = new HashSet<String>();
if (shaderDefines.Length > 0)
{
var tokens = shaderDefines.Split(new String[] { " ", "\t" }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 1; i < tokens.Length; ++i)
{
defines.Add(tokens[i]);
}
}
ShaderWrapper newShader = new ShaderWrapper()
{
m_ShaderFile = sf,
m_ShaderName = shaderName,
m_ShaderType = type,
m_ShaderEntry = shaderEntry,
m_Defines = defines
};
localShaders.Add(newShader);
}
if (matchNumThreadsRegex.Success)
{
int threadsX = Int32.Parse(matchNumThreadsRegex.Groups[1].Value);
int threadsY = Int32.Parse(matchNumThreadsRegex.Groups[2].Value);
int threadsZ = Int32.Parse(matchNumThreadsRegex.Groups[3].Value);
string nextLine = sr.ReadLine();
var tokens = nextLine.Split(new String[] { " ", "(" }, StringSplitOptions.RemoveEmptyEntries);
computeRegisters.Add(new Tuple<String, int, int, int>(tokens[1], threadsX, threadsY, threadsZ));
}
if (matchSamplerRegex.Success)
{
string samplerType = matchSamplerRegex.Groups[1].Value;
string samplerName = matchSamplerRegex.Groups[2].Value;
string samplerRegister = matchSamplerRegex.Groups[3].Value;
m_SamplerStates[Int32.Parse(samplerRegister)] = SamplerStates.GetSamplerStateForName(samplerName);
}
}
}
foreach (var shader in localShaders)
{
if (m_Shaders.ContainsKey(shader.m_ShaderName))
{
m_Shaders[shader.m_ShaderName] = shader;
}
else
{
m_Shaders.Add(shader.m_ShaderName, shader);
}
// CompileShader(shader);
if (shader.m_ShaderCompilationTask != null)
throw new Exception("Already compiling");
shader.m_ShaderCompilationTask = Task.Factory.StartNew(() => CompileShader(shader));
}
sf.m_FlattenedFiles.Add(sf.m_FileName);
sf.m_FlattenedFiles.UnionWith(sf.m_DirectlyIncludedFiles);
foreach (var registers in computeRegisters)
{
var shaderFit = localShaders.Where
(shader => shader.m_ShaderEntry == registers.Item1);
foreach (var fittingShader in shaderFit)
{
fittingShader.m_ThreadsX = registers.Item2;
fittingShader.m_ThreadsY = registers.Item3;
fittingShader.m_ThreadsZ = registers.Item4;
}
}
}
private static void CompileShader(ShaderWrapper shader)
{
bool done = false;
bool acquiredLock = false;
while (!done)
{
try
{
var defines = new ShaderMacro[shader.m_Defines.Count];
int counter = 0;
foreach (var define in shader.m_Defines)
{
defines[counter++] = new ShaderMacro(define, "1");
}
string profile = "";
switch (shader.m_ShaderType)
{
case ShaderType.PixelShader:
profile = "ps_5_0";
break;
case ShaderType.ComputeShader:
profile = "cs_5_0";
break;
case ShaderType.GeometryShader:
profile = "gs_5_0";
break;
case ShaderType.VertexShader:
profile = "vs_5_0";
break;
}
shader.m_ShaderBytecode = ShaderBytecode.CompileFromFile(shader.m_ShaderFile.m_FilePath, shader.m_ShaderEntry, profile, ShaderFlags.WarningsAreErrors, EffectFlags.None, defines, m_Include);
done = true;
}
catch (Exception e)
{
// if error - we need to enter synchronized state
if (!acquiredLock)
{
System.Threading.Monitor.TryEnter(m_Lock, ref acquiredLock);
}
// if we are first to aquire lock - show message box, allowing user to fix shader
if (acquiredLock)
{
System.Windows.Forms.MessageBox.Show(e.Message, "Shader compilation error");
}
else
{
// otherwise just enter without showing mb, will retry compilation after first shader is fixed
System.Threading.Monitor.Enter(m_Lock, ref acquiredLock);
}
}
}
if (acquiredLock)
{
System.Threading.Monitor.Exit(m_Lock);
}
}
public DynamicMeshRenderer(ShaderWrapper shaderWrapper, Mesh mesh, IDynamicMeshSource source = null) : base(shaderWrapper, mesh)
{
_source = source;
}
static ShaderManager()
{
m_Initialized = false;
m_Shaders = new Dictionary<string, ShaderWrapper>();
m_ConstantBuffers = new Dictionary<string, CustomConstantBufferDefinition>();
m_Watchers = new List<FileSystemWatcher>();
m_CurrentlyProcessedShader = null;
m_SamplerStates = new Dictionary<int, SamplerState>();
m_Lock = new Object();
m_FilesToReload = new HashSet<string>();
m_RegexWrapper = new RegexWrapper();
m_GlobalDefineValues = new Dictionary<string, float>();
}
private static void CompileShader(ShaderWrapper shader, Device device)
{
// hack to add includes to list to allow easy reloading after include has changed...
m_CurrentlyProcessedShader = shader;
bool done = false;
while (!done)
{
try
{
var defines = new ShaderMacro[shader.m_Defines.Count];
int counter = 0;
foreach (var define in shader.m_Defines)
{
defines[counter++] = new ShaderMacro(define, "1");
}
switch (shader.m_ShaderType)
{
case ShaderType.PixelShader:
using (var bytecode = ShaderBytecode.CompileFromFile(shader.m_FilePath, shader.m_ShaderEntry, "ps_5_0", ShaderFlags.WarningsAreErrors, EffectFlags.None, defines, m_Include))
shader.m_PixelShader = new PixelShader(device, bytecode);
break;
case ShaderType.ComputeShader:
using (var bytecode = ShaderBytecode.CompileFromFile(shader.m_FilePath, shader.m_ShaderEntry, "cs_5_0", ShaderFlags.WarningsAreErrors, EffectFlags.None, defines, m_Include))
shader.m_ComputeShader = new ComputeShader(device, bytecode);
break;
case ShaderType.GeometryShader:
using (var bytecode = ShaderBytecode.CompileFromFile(shader.m_FilePath, shader.m_ShaderEntry, "gs_5_0", ShaderFlags.WarningsAreErrors, EffectFlags.None, defines, m_Include))
shader.m_GeometryShader = new GeometryShader(device, bytecode);
break;
case ShaderType.VertexShader:
using (var bytecode = ShaderBytecode.CompileFromFile(shader.m_FilePath, shader.m_ShaderEntry, "vs_5_0", ShaderFlags.WarningsAreErrors, EffectFlags.None, defines, m_Include))
{
shader.m_VertexInputSignature = ShaderSignature.GetInputSignature(bytecode);
shader.m_VertexShader = new VertexShader(device, bytecode);
}
break;
}
done = true;
}
catch (Exception e)
{
System.Windows.Forms.MessageBox.Show(e.Message, "Shader compilation error");
}
}
m_CurrentlyProcessedShader = null;
if (m_Shaders.ContainsKey(shader.m_ShaderName))
{
m_Shaders[shader.m_ShaderName] = shader;
}
else
{
m_Shaders.Add(shader.m_ShaderName, shader);
}
}
public RenderMaterial(ShaderWrapper shaderWrapper)
{
d_shaderWrapper = shaderWrapper;
d_shaderParamBindings = new ShaderParameterBindings();
}
public Shader CreateFragmentShader(bool cg, string source, string entry, bool required)
{
try
{
ShaderWrapper sw = new ShaderWrapper();
if (cg)
{
var cgc = new CGC();
var results = cgc.Run(source, entry, "hlslf", true);
source = results.Code;
entry = "main";
if (!results.Succeeded)
{
if (required) throw new InvalidOperationException(results.Errors);
else return new Shader(this, null, false);
}
sw.MapCodeToNative = results.MapCodeToNative;
sw.MapNativeToCode = results.MapNativeToCode;
}
string errors = null;
d3d9.ShaderBytecode bytecode = null;
try
{
//cgc can create shaders that will need backwards compatibility...
string profile = "ps_1_0";
if (cg)
profile = "ps_3_0"; //todo - smarter logic somehow
//ShaderFlags.EnableBackwardsCompatibility - used this once upon a time (please leave a note about why)
//
bytecode = d3d9.ShaderBytecode.Compile(source, null, null, entry, profile, ShaderFlags.UseLegacyD3DX9_31Dll, out errors);
}
catch (Exception ex)
{
throw new InvalidOperationException("Error compiling shader: " + errors, ex);
}
sw.ps = new PixelShader(dev, bytecode);
sw.bytecode = bytecode;
Shader s = new Shader(this, sw, true);
sw.IGLShader = s;
return s;
}
catch
{
if (required)
throw;
else return new Shader(this, null, false);
}
}
private static void CompileShader(ShaderWrapper shader)
{
bool done = false;
bool acquiredLock = false;
while (!done)
{
try
{
var defines = new ShaderMacro[shader.m_Defines.Count];
int counter = 0;
foreach (var define in shader.m_Defines)
{
defines[counter++] = new ShaderMacro(define, "1");
}
string profile = "";
switch (shader.m_ShaderType)
{
case ShaderType.PixelShader:
profile = "ps_5_0";
break;
case ShaderType.ComputeShader:
profile = "cs_5_0";
break;
case ShaderType.GeometryShader:
profile = "gs_5_0";
break;
case ShaderType.VertexShader:
profile = "vs_5_0";
break;
}
shader.m_ShaderBytecode = ShaderBytecode.CompileFromFile(shader.m_ShaderFile.m_FilePath, shader.m_ShaderEntry, profile, ShaderFlags.WarningsAreErrors, EffectFlags.None, defines, m_Include);
done = true;
}
catch (Exception e)
{
// if error - we need to enter synchronized state
if (!acquiredLock)
{
System.Threading.Monitor.TryEnter(m_Lock, ref acquiredLock);
}
// if we are first to aquire lock - show message box, allowing user to fix shader
if (acquiredLock)
{
System.Windows.Forms.MessageBox.Show(e.Message, "Shader compilation error");
}
else
{
// otherwise just enter without showing mb, will retry compilation after first shader is fixed
System.Threading.Monitor.Enter(m_Lock, ref acquiredLock);
}
}
}
if (acquiredLock)
{
System.Threading.Monitor.Exit(m_Lock);
}
}
private static void FinalizeShader(ShaderWrapper shader, Device device)
{
switch (shader.m_ShaderType)
{
case ShaderType.PixelShader:
shader.m_ShaderObject = new PixelShader(device, shader.m_ShaderBytecode);
break;
case ShaderType.ComputeShader:
shader.m_ShaderObject = new ComputeShader(device, shader.m_ShaderBytecode);
break;
case ShaderType.GeometryShader:
shader.m_ShaderObject = new GeometryShader(device, shader.m_ShaderBytecode);
break;
case ShaderType.VertexShader:
shader.m_VertexInputSignature = ShaderSignature.GetInputSignature(shader.m_ShaderBytecode);
shader.m_ShaderObject = new VertexShader(device, shader.m_ShaderBytecode);
break;
}
shader.m_ShaderBytecode.Dispose();
shader.m_ShaderBytecode = null;
}
public void Render(SharpGL.OpenGL gl, ShaderWrapper shader)
{
m_vertexBuffer.Bind(gl);
gl.DrawArrays(SharpGL.OpenGL.GL_QUADS, 0, Vertices.Count);
m_vertexBuffer.Unbind(gl);
}
Shader CreateShader(bool cg, ShaderType type, string source, string entry, bool required)
{
var sw = new ShaderWrapper();
if (cg)
{
var cgc = new CGC();
var results = cgc.Run(source, entry, type == ShaderType.FragmentShader ? "glslf" : "glslv", false);
if (!results.Succeeded)
return new Shader(this, null, false);
source = results.Code;
sw.MapCodeToNative = results.MapCodeToNative;
sw.MapNativeToCode = results.MapNativeToCode;
}
int sid = GL.CreateShader(type);
bool ok = CompileShaderSimple(sid, source, required);
if(!ok)
{
GL.DeleteShader(sid);
sid = 0;
}
sw.sid = sid;
return new Shader(this, sw, ok);
}
public Shader CreateVertexShader(string source, bool required)
{
ShaderWrapper sw = new ShaderWrapper();
string errors;
using (var bytecode = d3d9.ShaderBytecode.Compile(source, null, null, "vsmain", "vs_2_0", ShaderFlags.None, out errors))
{
sw.ct = bytecode.ConstantTable;
sw.vs = new VertexShader(dev, bytecode);
}
Shader s = new Shader(this, IntPtr.Zero, true);
s.Opaque = sw;
return s;
}
private static void ParseFile(Device device, string path)
{
List <ShaderWrapper> localShaders = new List <ShaderWrapper>();
List <Tuple <string, int, int, int> > computeRegisters = new List <Tuple <String, int, int, int> >();
using (StreamReader sr = new StreamReader(path))
{
while (!sr.EndOfStream)
{
String line = sr.ReadLine();
Match matchShaderRegex = m_RegexWrapper.shaderRegex.Match(line);
Match matchCbufferRegex = m_RegexWrapper.cbufferRegex.Match(line);
Match matchSamplerRegex = m_RegexWrapper.samplerRegex.Match(line);
Match matchNumThreadsRegex = m_RegexWrapper.numThreadsRegex.Match(line);
Match matchGlobalDefineRegex = m_RegexWrapper.globalDefineRegex.Match(line);
if (matchGlobalDefineRegex.Success)
{
string defineName = matchGlobalDefineRegex.Groups[1].Value;
float value = Single.Parse(matchGlobalDefineRegex.Groups[2].Value, CultureInfo.InvariantCulture);
if (m_GlobalDefineValues.ContainsKey(defineName))
{
m_GlobalDefineValues[defineName] = value;
}
else
{
m_GlobalDefineValues.Add(defineName, value);
}
}
if (matchCbufferRegex.Success)
{
Match globalBufferMatch = m_RegexWrapper.globalBufferRegex.Match(line);
Match registerMatch = m_RegexWrapper.registerRegex.Match(line);
if (!registerMatch.Success)
{
throw new Exception("Unable to find register for constant buffer");
}
int cbufferRegister = Int32.Parse(registerMatch.Groups[1].Value);
// We have a new cbuffer
string cbufferName = matchCbufferRegex.Groups[1].Value;
string cbufferText = "";
while (!sr.EndOfStream)
{
line = sr.ReadLine();
if (line.Contains('{'))
{
continue;
}
if (line.Contains('}'))
{
if (m_ConstantBuffers.ContainsKey(cbufferName))
{
m_ConstantBuffers[cbufferName].ParseConstantBuffer(cbufferText, cbufferRegister, globalBufferMatch.Success);
}
else
{
CustomConstantBufferDefinition myNewConstantBuffer =
new CustomConstantBufferDefinition(
cbufferName,
cbufferText,
cbufferRegister,
globalBufferMatch.Success,
path);
m_ConstantBuffers.Add(cbufferName, myNewConstantBuffer);
}
break;
}
cbufferText += line.Trim() + "\n";
}
continue;
}
if (matchShaderRegex.Success)
{
// We have a new shader
string shaderType = matchShaderRegex.Groups[1].Value;
string shaderName = matchShaderRegex.Groups[2].Value;
string shaderEntry = matchShaderRegex.Groups[3].Value;
string shaderDefines = matchShaderRegex.Groups[4].Value;
ShaderType type = ShaderType.PixelShader;
switch (shaderType.ToLower())
{
case "pixel": type = ShaderType.PixelShader;
break;
case "vertex": type = ShaderType.VertexShader;
break;
case "compute": type = ShaderType.ComputeShader;
break;
case "geometry": type = ShaderType.GeometryShader;
break;
}
HashSet <string> defines = new HashSet <String>();
if (shaderDefines.Length > 0)
{
var tokens = shaderDefines.Split(new String[] { " ", "\t" }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 1; i < tokens.Length; ++i)
{
defines.Add(tokens[i]);
}
}
ShaderWrapper newShader = new ShaderWrapper()
{
m_FilePath = path,
m_ShaderName = shaderName,
m_ShaderType = type,
m_ShaderEntry = shaderEntry,
m_UsedIncludes = new HashSet <String>(),
m_Defines = defines
};
localShaders.Add(newShader);
}
if (matchNumThreadsRegex.Success)
{
int threadsX = Int32.Parse(matchNumThreadsRegex.Groups[1].Value);
int threadsY = Int32.Parse(matchNumThreadsRegex.Groups[2].Value);
int threadsZ = Int32.Parse(matchNumThreadsRegex.Groups[3].Value);
string nextLine = sr.ReadLine();
var tokens = nextLine.Split(new String[] { " ", "(" }, StringSplitOptions.RemoveEmptyEntries);
computeRegisters.Add(new Tuple <String, int, int, int>(tokens[1], threadsX, threadsY, threadsZ));
}
if (matchSamplerRegex.Success)
{
string samplerType = matchSamplerRegex.Groups[1].Value;
string samplerName = matchSamplerRegex.Groups[2].Value;
string samplerRegister = matchSamplerRegex.Groups[3].Value;
m_SamplerStates[Int32.Parse(samplerRegister)] = SamplerStates.GetSamplerStateForName(samplerName);
}
}
}
foreach (var shader in localShaders)
{
CompileShader(shader, device);
}
foreach (var registers in computeRegisters)
{
var shaderFit = localShaders.Where
(shader => shader.m_ShaderEntry == registers.Item1);
foreach (var fittingShader in shaderFit)
{
fittingShader.m_ThreadsX = registers.Item2;
fittingShader.m_ThreadsY = registers.Item3;
fittingShader.m_ThreadsZ = registers.Item4;
}
}
}
public Shader CreateFragmentShader(bool cg, string source, string entry, bool required)
{
ShaderWrapper sw = new ShaderWrapper();
if (cg)
{
var cgc = new CGC();
var results = cgc.Run(source, entry, "hlslf");
source = results.Code;
entry = "main";
if (!results.Succeeded)
{
if (required) throw new InvalidOperationException(results.Errors);
else return new Shader(this, null, false);
}
sw.MapCodeToNative = results.MapCodeToNative;
sw.MapNativeToCode = results.MapNativeToCode;
}
string errors = null;
d3d9.ShaderBytecode bytecode = null;
try
{
//cgc can create shaders that will need backwards compatibility...
bytecode = d3d9.ShaderBytecode.Compile(source, null, null, entry, "ps_3_0", ShaderFlags.EnableBackwardsCompatibility, out errors);
}
catch(Exception ex)
{
throw new InvalidOperationException("Error compiling shader: " + errors, ex);
}
sw.ps = new PixelShader(dev, bytecode);
sw.bytecode = bytecode;
Shader s = new Shader(this, sw, true);
sw.IGLShader = s;
return s;
}
