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>(); }
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 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; }