/// <summary>
/// Create a shader using a stream as the source and a ShaderType parameter.
/// </summary>
/// <param name="shaderType">The shader type (fragment or vertex)</param>
/// <param name="source">The stream for the shader.</param>
public Shader(ShaderType shaderType, Stream source) {
if (shaderType == ShaderType.Vertex) {
shader = new SFML.Graphics.Shader(source, null);
}
else {
shader = new SFML.Graphics.Shader(null, source);
}
}
public PixelShader(string filePath)
{
if (!SfmlShader.IsAvailable)
{
throw new ShaderNotSupportedException("Pixel shaders are not supported on this platform.");
}
SfmlShader = new SfmlShader(null, null, filePath);
}
/// <summary>
/// Create a shader using a stream as the source and a ShaderType parameter.
/// </summary>
/// <param name="shaderType">The shader type (fragment or vertex)</param>
/// <param name="source">The stream for the shader.</param>
public Shader(ShaderType shaderType, Stream source)
{
if (shaderType == ShaderType.Vertex)
{
shader = new SFML.Graphics.Shader(source, null);
}
else
{
shader = new SFML.Graphics.Shader(null, source);
}
}
/// <summary>
/// Creates a Shader using a file path source, and auto detects which type of shader
/// it is. If the file path contains ".frag" or ".fs" it is assumed to be a fragment shader.
/// </summary>
/// <param name="source">The file path.</param>
public Shader(string source)
{
if (source.Contains(".frag") || source.Contains(".fs"))
{
shader = new SFML.Graphics.Shader(null, source);
}
else
{
shader = new SFML.Graphics.Shader(source, null);
}
}
/// <summary>
/// Creates a shader using a file path and a ShaderType parameter.
/// </summary>
/// <param name="shaderType">The shader type (fragment or vertex)</param>
/// <param name="source">The file path.</param>
public Shader(ShaderType shaderType, string source)
{
if (shaderType == ShaderType.Vertex)
{
SFMLShader = new SFML.Graphics.Shader(source, null, null);
}
else
{
SFMLShader = new SFML.Graphics.Shader(null, null, source);
}
}
/// <summary>
/// Creates a Shader using a file path source, and auto detects which type of shader
/// it is. If the file path contains ".frag" or ".fs" it is assumed to be a fragment shader.
/// </summary>
/// <param name="source">The file path.</param>
public Shader(string source)
{
var str = System.Text.Encoding.Default.GetString(Files.LoadFileBytes(source));
if (source.Contains(".frag") || source.Contains(".fs"))
{
SFMLShader = new SFML.Graphics.Shader(null, null, str);
}
else
{
SFMLShader = new SFML.Graphics.Shader(str, null, null);
}
}
private void InitPreview()
{
m_sfmlControl.Dock = DockStyle.Fill;
m_sfmlControl.DrawDelegates.Add(this.DrawPreviewNoLighting);
m_sfmlControl.UpdateDelegates.Add(this.UpdateSprites);
panelEditorOuter.Controls.Add(m_sfmlControl);
//create layers to hold sprites
for (var i = 0; i < Enum.GetValues(typeof(Layer)).Length; ++i)
{
m_previewLayers.Add(new List <SFML.Graphics.RectangleShape>());
}
byte[] va = Encoding.UTF8.GetBytes(lightShaderVert);
MemoryStream vs = new MemoryStream(va);
byte[] fa = Encoding.UTF8.GetBytes("#version 130\n#define TEXTURE\n" + lightShaderFrag);
MemoryStream fs = new MemoryStream(fa);
m_lightShaderTextured = new SFML.Graphics.Shader(vs, fs);
fa = Encoding.UTF8.GetBytes("#version 130\n#define COLOUR\n" + lightShaderFrag);
fs = new MemoryStream(fa);
m_lightShaderColoured = new SFML.Graphics.Shader(vs, fs);
var colour = panelAmbientColour.BackColor;
m_ambientColour = new SFML.Graphics.Color(colour.R, colour.G, colour.B);
colour = panelSunColour.BackColor;
m_sunColour = new SFML.Graphics.Color(colour.R, colour.G, colour.B);
m_sfmlControl.MouseDown += m_sfmlControl_MouseDown;
m_sfmlControl.MouseUp += m_sfmlControl_MouseUp;
m_sfmlControl.MouseMove += m_sfmlControl_MouseMove;
m_sfmlControl.MouseClick += m_sfmlControl_MouseClick;
}
internal Shader(SFML.Graphics.Shader shader) {
this.shader = shader;
}
/// <summary>
/// Creates a Shader using a file path source, and auto detects which type of shader
/// it is. If the file path contains ".frag" or ".fs" it is assumed to be a fragment shader.
/// </summary>
/// <param name="source">The file path.</param>
public Shader(string source) {
if (source.Contains(".frag") || source.Contains(".fs")) {
shader = new SFML.Graphics.Shader(null, source);
}
else {
shader = new SFML.Graphics.Shader(source, null);
}
}
private Shader()
{
_shader = null;
}
public GLSLShader(Stream vertexShaderStream, Stream fragmentShaderStream)
{
SFMLShader = new ShaderClass(vertexShaderStream, null, fragmentShaderStream);
}
public GLSLShader(string vertexShaderFilename, string fragmentShaderFilename)
{
SFMLShader = new ShaderClass(vertexShaderFilename, null, fragmentShaderFilename);
}
/// <summary>
/// Creates a Shader using a file as the source for the vertex and fragment shader.
/// </summary>
/// <param name="vertexFile">The file path to the vertex shader.</param>
/// <param name="fragmentFile">The file path to the fragment shader.</param>
public Shader(string vertexFile, string fragmentFile)
{
SFMLShader = new SFML.Graphics.Shader(Files.LoadFileStream(vertexFile), null, Files.LoadFileStream(fragmentFile));
}
internal Shader(SFML.Graphics.Shader shader)
{
this.SFMLShader = shader;
}
/// <summary>
/// Load both the vertex and fragment shaders from source codes in memory
///
/// This function can load both the vertex and the fragment
/// shaders, or only one of them: pass NULL if you don't want to load
/// either the vertex shader or the fragment shader.
/// The sources must be valid shaders in GLSL language. GLSL is
/// a C-like language dedicated to OpenGL shaders; you'll
/// probably need to read a good documentation for it before
/// writing your own shaders.
/// </summary>
/// <param name="vertexShader">String containing the source code of the vertex shader</param>
/// <param name="fragmentShader">String containing the source code of the fragment shader</param>
/// <returns>New shader instance</returns>
public static SFML.Graphics.Shader FromString(string vertexShader, string fragmentShader)
{
SFML.Graphics.Shader shader = new SFML.Graphics.Shader(vertexShader, null, fragmentShader);
return(shader);
}
public Shader(string source)
{
_shader = new SFML.Graphics.Shader(source);
}
/// <summary>
/// Creates a Shader using a file as the source for the vertex and fragment shader.
/// </summary>
/// <param name="vertexFile">The file path to the vertex shader.</param>
/// <param name="fragmentFile">The file path to the fragment shader.</param>
public Shader(string vertexFile, string fragmentFile) {
shader = new SFML.Graphics.Shader(vertexFile, fragmentFile);
}
/// <summary>
/// Create a Shader using a stream as the source of the vertex and fragment shader.
/// </summary>
/// <param name="vertexStream">The stream for the vertex shader.</param>
/// <param name="fragmentStream">The stream for the fragment shader.</param>
public Shader(Stream vertexStream, Stream fragmentStream)
{
SFMLShader = new SFML.Graphics.Shader(vertexStream, null, fragmentStream);
}
/// <summary>
/// Creates a Shader using a file as the source for the vertex and fragment shader.
/// </summary>
/// <param name="vertexFile">The file path to the vertex shader.</param>
/// <param name="fragmentFile">The file path to the fragment shader.</param>
public Shader(string vertexFile, string fragmentFile)
{
shader = new SFML.Graphics.Shader(vertexFile, fragmentFile);
}
/// <summary>
/// Create a Shader using a stream as the source of the vertex and fragment shader.
/// </summary>
/// <param name="vertexStream">The stream for the vertex shader.</param>
/// <param name="fragmentStream">The stream for the fragment shader.</param>
public Shader(Stream vertexStream, Stream fragmentStream) {
shader = new SFML.Graphics.Shader(vertexStream, fragmentStream);
}
private void ActivateShader_Click(object sender, RoutedEventArgs e)
{
ShaderErrorBox.Document.Blocks.Clear();
if (SFML.Graphics.Shader.IsAvailable)
{
string shaderText = new TextRange(ShaderEditorBox.Document.ContentStart, ShaderEditorBox.Document.ContentEnd).Text;
if (shaderText.Length < 1)
{
ShaderErrorBox.AppendText("Error: There is no shader data.");
}
else
{
if (TestShader != null)
{
TestShader.Dispose();
}
try
{
lock (ShaderControl.DrawLocked)
{
TestShader = SFML.Graphics.Shader.FromString(shaderText);
TestShader.SetCurrentTexture(selfTexture);
if (UseImageRes.IsChecked == true && ShaderSprite != null)
{
TestShader.SetParameter(resParam, 1.0f, 1.0f);
}
else
{
TestShader.SetParameter(resParam, (float)ShaderControl.Width, (float)ShaderControl.Height);
}
if (ShaderControl != null)
{
ShaderControl.GlobalShader = TestShader;
}
ShaderTimer.Reset();
ShaderTimer.Start();
TestShader.SetParameter(timeParam, (float)ShaderTimer.ElapsedMilliseconds);
}
}
catch (SFML.LoadingFailedException ex)
{
ShaderErrorBox.AppendText("Error: " + ex.Message);
}
catch (Exception ex)
{
ShaderErrorBox.AppendText("Error: " + ex.Message);
}
}
}
else
{
ShaderErrorBox.AppendText("Error: Your system does not support shaders.");
}
}
