private void init(string fileName, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) { try { video = Parent.FindParentOrSelfWithException <Video>(); program = new ShaderProgram("/Application/" + fileName.Replace(".rs", ".cgx")); variables = new List <ShaderVariable>(); resources = new List <ShaderResource>(); } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) { loadedCallback(this, false); } return; } Loaded = true; if (loadedCallback != null) { loadedCallback(this, true); } }
public Shader(DisposableI parent, string fileName, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { #if SILVERLIGHT new StreamLoader(Streams.StripFileExt(fileName) + ".mrs", delegate(object sender, bool succeeded) { if (succeeded) { init(fileName, ((StreamLoader)sender).LoadedStream, shaderVersion, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) { loadedCallback(this, false); } } }); #else init(fileName, null, shaderVersion, loadedCallback); #endif }
public Shader(IDisposableResource parent, string filename, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { #if WINRT || WP8 Loader.AddLoadable(this); filename = Streams.StripFileExt(filename) + ".mrs"; #endif new StreamLoader(filename, delegate(object sender, bool succeeded) { if (succeeded) { init(filename, ((StreamLoader)sender).LoadedStream, shaderVersion, vsQuality, psQuality, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) { loadedCallback(this, false); } } }); }
private void init(string filename, Stream stream, ShaderVersions shaderVersion, Loader.LoadedCallbackMethod loadedCallback) { try { video = Parent.FindParentOrSelfWithException <Video>(); var code = getShaders(stream); vertex = new VertexShader(this, code[0], (shaderVersion == ShaderVersions.Max) ? video.Caps.MaxVertexShaderVersion : shaderVersion); pixel = new PixelShader(this, code[1], (shaderVersion == ShaderVersions.Max) ? video.Caps.MaxPixelShaderVersion : shaderVersion); variables = new List <ShaderVariable>(); resources = new List <ShaderResource>(); } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) { loadedCallback(this, false); } return; } Loaded = true; if (loadedCallback != null) { loadedCallback(this, true); } }
private void init(string filename, Stream stream, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) #endif { try { video = Parent.FindParentOrSelfWithException<Video>(); #if WIN32 shaderVersion = (shaderVersion == ShaderVersions.Max) ? video.Cap.MaxShaderVersion : shaderVersion; var code = getShaders(stream); vertex = new VertexShader(this, code[0], shaderVersion); pixel = new PixelShader(this, code[1], shaderVersion); #else await getReflections(filename); var code = getShaders(stream); vertex = new VertexShader(this, code[0]); pixel = new PixelShader(this, code[1]); #endif variables = new List<ShaderVariable>(); resources = new List<ShaderResource>(); } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
public static IShader New(VideoTypes videoType, IDisposableResource parent, string filename, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) { IShader api = null; #if WIN32 if (videoType == VideoTypes.D3D9) api = new D3D9.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); #endif #if WIN32 || WINRT || WP8 if (videoType == VideoTypes.D3D11) api = new D3D11.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); #endif #if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl if (videoType == VideoTypes.OpenGL) api = new OpenGL.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); #endif #if XNA if (videoType == VideoTypes.XNA) api = new XNA.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); #endif #if VITA if (videoType == VideoTypes.Vita) api = new Vita.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); #endif if (api == null) Debug.ThrowError("ShaderAPI", "Unsuported InputType: " + videoType); return api; }
public static void Init(DisposableI parent, string contentPath, string tag, ShaderVersions shaderVersion, Loader.LoadedCallbackMethod loadedCallback) { Shader = ShaderAPI.New(parent, contentPath + tag + "QuickDraw3Color.rs", shaderVersion, delegate(object sender, bool succeeded) { if (succeeded) { init((ShaderI)sender, loadedCallback); } else { FailedToLoad = true; if (loadedCallback != null) loadedCallback(null, false); } }); }
public ShaderModel(IDisposableResource parent, string code, ShaderVersions shaderVersion, ShaderTypes shaderType) : base(parent) { try { var video = parent.FindParentOrSelfWithException <Video>(); string shaderLvl = ""; switch (shaderVersion) { case ShaderVersions.HLSL_2_0: shaderLvl = "_2_0"; break; case ShaderVersions.HLSL_2_a: shaderLvl = "_2_a"; break; case ShaderVersions.HLSL_3_0: shaderLvl = "_3_0"; break; default: Debug.ThrowError("ShaderModel", "Unsuported ShaderVersion: " + shaderVersion); break; } string shaderVersionType = shaderType.ToString().ToLower() + shaderLvl; com = new ShaderModelCom(); var codePtr = Marshal.StringToHGlobalAnsi(code); var shaderVersionTypePtr = Marshal.StringToHGlobalAnsi(shaderVersionType); string errorText; var error = com.Init(video.com, codePtr, code.Length, shaderVersionTypePtr, out errorText); if (codePtr != IntPtr.Zero) { Marshal.FreeHGlobal(codePtr); } if (shaderVersionTypePtr != IntPtr.Zero) { Marshal.FreeHGlobal(shaderVersionTypePtr); } switch (error) { case ShaderModelErrors.Compile: Debug.ThrowError("ShaderModel", string.Format("Failed to compile {0} shader: Errors: {1}", shaderType == ShaderTypes.VS ? "vs" : "ps", errorText)); break; } } catch (Exception e) { Dispose(); throw e; } }
public static void Init(DisposableI parent, string contentPath, string tag, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) { Shader = ShaderAPI.New(parent, contentPath + tag + "UISolidColor.rs", shaderVersion, vsQuality, psQuality, delegate(object sender, bool succeeded) { if (succeeded) { init((ShaderI)sender, loadedCallback); } else { FailedToLoad = true; if (loadedCallback != null) { loadedCallback(null, false); } } }); }
public static void Init(DisposableI parent, string contentPath, string tag, ShaderVersions shaderVersion, Loader.LoadedCallbackMethod loadedCallback) { Shader = ShaderAPI.New(parent, contentPath + tag + "QuickDraw3ColorUV.rs", shaderVersion, delegate(object sender, bool succeeded) { if (succeeded) { init((ShaderI)sender, loadedCallback); } else { FailedToLoad = true; if (loadedCallback != null) { loadedCallback(null, false); } } }); }
private void init(Stream stream, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) { try { video = Parent.FindParentOrSelfWithException <Video>(); shaderVersion = (shaderVersion == ShaderVersions.Max) ? this.video.Caps.MaxShaderVersion : shaderVersion; var code = getShaders(stream); vertex = new VertexShader(this, code[0], shaderVersion, vsQuality); pixel = new PixelShader(this, code[1], shaderVersion, psQuality); program = GL.CreateProgram(); if (program == 0) { Debug.ThrowError("Shader", "Failed to create shader program"); } GL.AttachShader(program, vertex.Shader); GL.AttachShader(program, pixel.Shader); GL.LinkProgram(program); variables = new List <ShaderVariable>(); resources = new List <ShaderResource>(); Video.checkForError(); } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) { loadedCallback(this, false); } return; } Loaded = true; if (loadedCallback != null) { loadedCallback(this, true); } }
private void init(string filename, Stream stream, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) #endif { try { video = Parent.FindParentOrSelfWithException <Video>(); #if WIN32 shaderVersion = (shaderVersion == ShaderVersions.Max) ? video.Cap.MaxShaderVersion : shaderVersion; var code = getShaders(stream); vertex = new VertexShader(this, code[0], shaderVersion); pixel = new PixelShader(this, code[1], shaderVersion); #else await getReflections(filename); var code = getShaders(stream); vertex = new VertexShader(this, code[0]); pixel = new PixelShader(this, code[1]); #endif variables = new List <ShaderVariable>(); resources = new List <ShaderResource>(); } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) { loadedCallback(this, false); } return; } Loaded = true; if (loadedCallback != null) { loadedCallback(this, true); } }
public Shader(IDisposableResource parent, string filename, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { new StreamLoader(filename, delegate(object sender, bool succeeded) { if (succeeded) { init(filename, ((StreamLoader)sender).LoadedStream, shaderVersion, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) { loadedCallback(this, false); } } }); }
public VertexShader(IDisposableResource parent, string code, ShaderVersions shaderVersion) : base(parent, code, shaderVersion, ShaderTypes.VS) { try { var video = parent.FindParentOrSelfWithException<Video>(); vertexShaderCom = new VertexShaderCom(); var error = vertexShaderCom.Init(video.com, com); switch (error) { case VertexShaderErrors.VertexShader: Debug.ThrowError("VertexShader", "Failed to create vertex shader"); break; } } catch (Exception e) { Dispose(); throw e; } }
public VertexShader(IDisposableResource parent, string code, ShaderVersions shaderVersion) : base(parent, code, shaderVersion, ShaderTypes.VS) { try { var video = parent.FindParentOrSelfWithException <Video>(); vertexShaderCom = new VertexShaderCom(); var error = vertexShaderCom.Init(video.com, com); switch (error) { case VertexShaderErrors.VertexShader: Debug.ThrowError("VertexShader", "Failed to create vertex shader"); break; } } catch (Exception e) { Dispose(); throw e; } }
public Shader(IDisposableResource parent, string filename, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { #if WINRT || WP8 Loader.AddLoadable(this); filename = Streams.StripFileExt(filename) + ".mrs"; #endif new StreamLoader(filename, delegate(object sender, bool succeeded) { if (succeeded) { init(filename, ((StreamLoader)sender).LoadedStream, shaderVersion, vsQuality, psQuality, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) loadedCallback(this, false); } }); }
public Shader(DisposableI parent, string fileName, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { #if SILVERLIGHT new StreamLoader(Streams.StripFileExt(fileName) + ".mrs", delegate(object sender, bool succeeded) { if (succeeded) { init(fileName, ((StreamLoader)sender).LoadedStream, shaderVersion, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) loadedCallback(this, false); } }); #else init(fileName, null, shaderVersion, loadedCallback); #endif }
private void init(string fileName, Stream stream, ShaderVersions shaderVersion, Loader.LoadedCallbackMethod loadedCallback) { try { #if SILVERLIGHT video = Parent.FindParentOrSelfWithException <Video>(); getReflections(fileName); var code = getShaders(stream); vertex = new VertexShader(video.Device, code[0]); pixel = new PixelShader(video.Device, code[1]); #else effect = Parent.FindParentOrSelfWithException <RootDisposable>().Content.Load <Effect>(Streams.StripFileExt(fileName)); loadedFromContentManager = true; pass = effect.CurrentTechnique.Passes[0]; #endif variables = new List <ShaderVariable>(); resources = new List <ShaderResource>(); } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) { loadedCallback(this, false); } } Loaded = true; if (loadedCallback != null) { loadedCallback(this, true); } }
public static void Init(DisposableI parent, string contentPath, string tag, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) { Shader = ShaderAPI.New(parent, contentPath + tag + "UISolidTexture2.rs", shaderVersion, vsQuality, psQuality, delegate(object sender, bool succeeded) { if (succeeded) { init((ShaderI)sender, loadedCallback); } else { FailedToLoad = true; if (loadedCallback != null) loadedCallback(null, false); } }); }
private void init(string fileName, Stream stream, ShaderVersions shaderVersion, Loader.LoadedCallbackMethod loadedCallback) { try { #if SILVERLIGHT video = Parent.FindParentOrSelfWithException<Video>(); getReflections(fileName); var code = getShaders(stream); vertex = new VertexShader(video.Device, code[0]); pixel = new PixelShader(video.Device, code[1]); #else effect = Parent.FindParentOrSelfWithException<RootDisposable>().Content.Load<Effect>(Streams.StripFileExt(fileName)); loadedFromContentManager = true; pass = effect.CurrentTechnique.Passes[0]; #endif variables = new List<ShaderVariable>(); resources = new List<ShaderResource>(); } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) loadedCallback(this, false); } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
public static Shader New(DisposableI parent, string fileName, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) { return new Shader(parent, fileName, shaderVersion, vsQuality, psQuality, loadedCallback); }
public static Shader New(DisposableI parent, string fileName, ShaderVersions shaderVersion, Loader.LoadedCallbackMethod loadedCallback) { return new Shader(parent, fileName, shaderVersion, loadedCallback); }
public VertexShader(Shader shader, string code, ShaderVersions shaderVersion) : base(shader, code, ShaderTypes.VS, shaderVersion)
public VertexShader(IShader shader, string code, ShaderVersions shaderVersion) : base(shader, code, shaderVersion, ShaderTypes.VS, ShaderFloatingPointQuality.High) { }
public ShaderModel(Shader shader, string code, ShaderTypes shaderType, ShaderVersions shaderVersion)
public static Shader New(DisposableI parent, string fileName, ShaderVersions shaderVersion, Loader.LoadedCallbackMethod loadedCallback) { return(new Shader(parent, fileName, shaderVersion, loadedCallback)); }
private void init(string fileName, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) { try { video = Parent.FindParentOrSelfWithException<Video>(); program = new ShaderProgram("/Application/" + fileName.Replace(".rs", ".cgx")); variables = new List<ShaderVariable>(); resources = new List<ShaderResource>(); } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
public Shader(DisposableI parent, string fileName, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { init(fileName, shaderVersion, vsQuality, psQuality, loadedCallback); }
public PixelShader(IShader shader, string code, ShaderVersions shaderVersion) : base(shader, code, shaderVersion, ShaderTypes.PS, ShaderFloatingPointQuality.Low) { }
public static Shader New(DisposableI parent, string fileName, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) { return(new Shader(parent, fileName, shaderVersion, vsQuality, psQuality, loadedCallback)); }
public PixelShader(Shader shader, string code, ShaderVersions shaderVersion) : base(shader, code, ShaderTypes.PS, shaderVersion)
private async void init(string filename, Stream stream, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback)
public PixelShader(Shader shader, string code, ShaderVersions shaderVersion) : base(shader, code, ShaderTypes.PS, shaderVersion)
public static IShader New(IDisposableResource parent, string filename, ShaderVersions shaderVersion, Loader.LoadedCallbackMethod loadedCallback) { return(New(VideoAPI.DefaultAPI, parent, filename, shaderVersion, ShaderFloatingPointQuality.High, ShaderFloatingPointQuality.Low, loadedCallback)); }
public unsafe ShaderModel(IShader shader, string code, ShaderVersions shaderVersion, ShaderTypes shaderType, ShaderFloatingPointQuality quality) : base(shader) { try { Shader = GL.CreateShader((shaderType == ShaderTypes.VS) ? GL.VERTEX_SHADER : GL.FRAGMENT_SHADER); if (Shader == 0) { Debug.ThrowError("ShaderModel", string.Format("Failed to create {0} shader", (shaderType == ShaderTypes.VS) ? "vs": "ps")); } #if iOS || ANDROID || NaCl code = getQualityText(quality) + Environment.NewLine + code; #endif string shaderLvl = ""; switch (shaderVersion) { #if iOS || ANDROID || NaCl || RPI case ShaderVersions.GLSL_1_00: shaderLvl = "100"; break; #else case ShaderVersions.GLSL_1_10: shaderLvl = "110"; break; case ShaderVersions.GLSL_1_20: shaderLvl = "120"; break; case ShaderVersions.GLSL_1_30: shaderLvl = "130"; break; case ShaderVersions.GLSL_1_40: shaderLvl = "140"; break; case ShaderVersions.GLSL_1_50: shaderLvl = "150"; break; case ShaderVersions.GLSL_3_30: shaderLvl = "330"; break; #endif default: Debug.ThrowError("ShaderModel", "Unsuported ShaderVersion: " + shaderVersion); break; } code = "#version " + shaderLvl + Environment.NewLine + code; int codeLength = code.Length; fixed(byte *codeData = code.CastToBytes()) { byte *codeData2 = codeData; GL.ShaderSource(Shader, 1, &codeData2, &codeLength); GL.CompileShader(Shader); } int result = 0; GL.GetShaderiv(Shader, GL.COMPILE_STATUS, &result); if (result == 0) { int logLength = 0; GL.GetShaderiv(Shader, GL.INFO_LOG_LENGTH, &logLength); byte *logPtr = stackalloc byte[logLength]; GL.GetShaderInfoLog(Shader, logLength, &result, logPtr); byte[] log = new byte[logLength]; System.Runtime.InteropServices.Marshal.Copy(new IntPtr(logPtr), log, 0, logLength); Debug.ThrowError("ShaderModel", string.Format("{0} Shader compile error: {1}", shaderType, System.Text.ASCIIEncoding.ASCII.GetString(log))); } Video.checkForError(); } catch (Exception e) { Dispose(); throw e; } }
public VertexShader(IShader shader, string code, ShaderVersions shaderVersion, ShaderFloatingPointQuality quality) : base(shader, code, shaderVersion, ShaderTypes.VS, quality) { }
public ShaderModel(Shader shader, string code, ShaderTypes shaderType, ShaderVersions shaderVersion)
private async void init(string filename, Stream stream, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback)
public static IShader New(VideoTypes videoType, IDisposableResource parent, string filename, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) { IShader api = null; #if WIN32 if (videoType == VideoTypes.D3D9) { api = new D3D9.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); } #endif #if WIN32 || WINRT || WP8 if (videoType == VideoTypes.D3D11) { api = new D3D11.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); } #endif #if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl if (videoType == VideoTypes.OpenGL) { api = new OpenGL.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); } #endif #if XNA if (videoType == VideoTypes.XNA) { api = new XNA.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); } #endif #if VITA if (videoType == VideoTypes.Vita) { api = new Vita.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); } #endif if (api == null) { Debug.ThrowError("ShaderAPI", "Unsuported InputType: " + videoType); } return(api); }
public static IShader New(IDisposableResource parent, string filename, ShaderVersions shaderVersion, Loader.LoadedCallbackMethod loadedCallback) { return New(VideoAPI.DefaultAPI, parent, filename, shaderVersion, ShaderFloatingPointQuality.High, ShaderFloatingPointQuality.Low, loadedCallback); }
public Shader(DisposableI parent, string fileName, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { init(fileName, shaderVersion, vsQuality, psQuality, loadedCallback); }