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);
}
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 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;
}
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);
}
}
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 string getQualityText(ShaderFloatingPointQuality quality)
{
switch (quality)
{
case ShaderFloatingPointQuality.High: return("precision highp float;");
case ShaderFloatingPointQuality.Med: return("precision mediump float;");
case ShaderFloatingPointQuality.Low: return("precision lowp float;");
case ShaderFloatingPointQuality.Max:
return
(@"
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
");
}
return(null);
}
private async void init(string filename, Stream stream, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback)
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 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 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 Shader(DisposableI parent, string fileName, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback)
: base(parent)
{
init(fileName, shaderVersion, vsQuality, psQuality, loadedCallback);
}
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 static IShader New(IDisposableResource parent, string filename, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback)
{
return New(VideoAPI.DefaultAPI, parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback);
}
public PixelShader(IShader shader, string code, ShaderVersions shaderVersion, ShaderFloatingPointQuality quality)
: base(shader, code, shaderVersion, ShaderTypes.PS, quality)
{
}
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 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, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback)
{
return(New(VideoAPI.DefaultAPI, parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback));
}
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 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 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(IShader shader, string code, ShaderVersions shaderVersion, ShaderFloatingPointQuality quality)
: base(shader, code, shaderVersion, ShaderTypes.VS, quality)
{
}
private async void init(string filename, Stream stream, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod 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 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 Shader(DisposableI parent, string fileName, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback)
: base(parent)
{
init(fileName, shaderVersion, vsQuality, psQuality, loadedCallback);
}
