private void glControl1_Load(object sender, EventArgs e)
{
loaded = true;
stopwatch.Start();
// glControl1.MouseWheel += new MouseEventHandler(glControl1_MouseWheel);
// setupViewport();
// displayList = GL.GenLists(1);
// declare some variables for tracking which shader did compile, and which texture to use
String LogInfo;
// Load&Compile Vertex Shader
using (StreamReader sr = new StreamReader("./shaders/vertex_shader.glsl"))
{
VertexShaderObject = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(VertexShaderObject, sr.ReadToEnd());
GL.CompileShader(VertexShaderObject);
}
GL.GetShaderInfoLog(VertexShaderObject, out LogInfo);
if (LogInfo.Length > 0 && !LogInfo.Contains("hardware"))
{
Trace.WriteLine("Vertex Shader Log:\n" + LogInfo);
}
else
{
Trace.WriteLine("Vertex Shader compiled without complaint.");
}
ShaderFilename = ShaderDir + ShaderName + ShaderExt;
getShaderList(ShaderDir, ShaderName, ShaderExt);
compileShader();
}
float UniformOffsetY = 1.8f; // fractal vertical offset
#endregion private Fields
#region OnLoad
/// <summary>
/// Setup OpenGL and load resources here.
/// </summary>
/// <param name="e">Not used.</param>
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
// Check for necessary capabilities:
Version version = new Version(GL.GetString(StringName.Version).Substring(0, 3));
Version target = new Version(2, 0);
if (version < target)
{
throw new NotSupportedException(String.Format(
"OpenGL {0} is required (you only have {1}).", target, version));
}
this.VSync = VSyncMode.On;
GL.Disable(EnableCap.Dither);
GL.ClearColor(0.2f, 0f, 0.4f, 0f);
// declare some variables for tracking which shader did compile, and which texture to use
string[] ShaderFilenames = new string[2];
ShaderFilenames[0] = "Data/Shaders/JuliaSet_SM3_FS.glsl";
ShaderFilenames[1] = "Data/Shaders/JuliaSet_SM2_FS.glsl";
string LogInfo;
int status = 0;
#region Shaders
// Load&Compile Vertex Shader
using (StreamReader sr = new StreamReader("Data/Shaders/JuliaSet_VS.glsl"))
{
VertexShaderObject = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(VertexShaderObject, sr.ReadToEnd());
GL.CompileShader(VertexShaderObject);
}
GL.GetShaderInfoLog(VertexShaderObject, out LogInfo);
if (LogInfo.Length > 0 && !LogInfo.Contains("hardware"))
{
Trace.WriteLine("Vertex Shader Log:\n" + LogInfo);
}
else
{
Trace.WriteLine("Vertex Shader compiled without complaint.");
}
// Load&Compile Fragment Shader
FragmentShaderObject = GL.CreateShader(ShaderType.FragmentShader);
foreach (var shader in ShaderFilenames)
{
using (StreamReader sr = new StreamReader(shader))
{
GL.ShaderSource(FragmentShaderObject, sr.ReadToEnd());
GL.CompileShader(FragmentShaderObject);
}
GL.GetShader(FragmentShaderObject, ShaderParameter.CompileStatus, out status);
if (status != 1)
{
GL.GetShaderInfoLog(FragmentShaderObject, out LogInfo);
Trace.WriteLine("Compiling " + shader + " failed!\nLog:\n" + LogInfo);
}
else
{
Trace.WriteLine("Fragment Shader compiled without complaint.");
break;
}
}
if (status != 1)
{
MessageBox.Show("Shader compilation failed");
Exit();
}
// Link the Shaders to a usable Program
ProgramObject = GL.CreateProgram();
GL.AttachShader(ProgramObject, VertexShaderObject);
GL.AttachShader(ProgramObject, FragmentShaderObject);
GL.LinkProgram(ProgramObject);
// make current
GL.UseProgram(ProgramObject);
// Flag ShaderObjects for delete when app exits
GL.DeleteShader(VertexShaderObject);
GL.DeleteShader(FragmentShaderObject);
#endregion Shaders
#region Textures
// Load&Bind the 1D texture for color lookups
GL.ActiveTexture(TextureUnit.Texture0); // select TMU0
GL.GenTextures(1, out TextureObject);
GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureWrapS, (int)(TextureWrapMode)All.ClampToEdge);
using (Bitmap bitmap = new Bitmap("Data/Textures/JuliaColorTable.bmp"))
{
BitmapData data = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format24bppRgb);
GL.TexImage1D(TextureTarget.Texture1D, 0, PixelInternalFormat.Rgb8, data.Width, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgr,
PixelType.UnsignedByte, data.Scan0);
bitmap.UnlockBits(data);
}
#endregion Textures
Keyboard.KeyUp += KeyUp;
}
public Shader(string VSUrl, string FSUrl)
{
// First call Core.Shader.Init();
if ((!Core.useGLSL) || (!Core.CheckGLSLSupport()))
{
return;
}
active = false;
using (StreamReader sr = new StreamReader(VSUrl))
{
VertexShaderObject = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(VertexShaderObject, sr.ReadToEnd());
GL.CompileShader(VertexShaderObject);
}
ErrorCode err;
err = GL.GetError();
if (err != ErrorCode.NoError)
{
Debug.Trace("Vertex Shader: " + err);
}
string LogInfo;
GL.GetShaderInfoLog(VertexShaderObject, out LogInfo);
if (LogInfo.Length > 0 && !LogInfo.Contains("hardware"))
{
Debug.Trace("Vertex Shader failed!\nLog:\n" + LogInfo);
}
else
{
Debug.Trace("Vertex Shader compiled without complaint.");
}
// Load&Compile Fragment Shader
using (StreamReader sr = new StreamReader(FSUrl))
{
FragmentShaderObject = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(FragmentShaderObject, sr.ReadToEnd());
GL.CompileShader(FragmentShaderObject);
}
GL.GetShaderInfoLog(FragmentShaderObject, out LogInfo);
err = GL.GetError();
if (err != ErrorCode.NoError)
{
Debug.Trace("Fragment Shader: " + err);
}
if (LogInfo.Length > 0 && !LogInfo.Contains("hardware"))
{
Debug.Trace("Fragment Shader failed!\nLog:\n" + LogInfo);
}
else
{
Debug.Trace("Fragment Shader compiled without complaint.");
}
// Link the Shaders to a usable Program
ProgramObject = GL.CreateProgram();
GL.AttachShader(ProgramObject, VertexShaderObject);
GL.AttachShader(ProgramObject, FragmentShaderObject);
// link it all together
GL.LinkProgram(ProgramObject);
err = GL.GetError();
if (err != ErrorCode.NoError)
{
Debug.Trace("LinkProgram: " + err);
}
GL.UseProgram(ProgramObject);
err = GL.GetError();
if (err != ErrorCode.NoError)
{
Debug.Trace("UseProgram: " + err);
}
// flag ShaderObjects for delete when not used anymore
GL.DeleteShader(VertexShaderObject);
GL.DeleteShader(FragmentShaderObject);
int temp;
GL.GetProgram(ProgramObject, ProgramParameter.LinkStatus, out temp);
Debug.Trace("Linking Program (" + ProgramObject + ") " + ((temp == 1) ? "succeeded." : "FAILED!"));
if (temp != 1)
{
GL.GetProgramInfoLog(ProgramObject, out LogInfo);
Debug.Trace("Program Log:\n" + LogInfo);
}
Debug.Trace("End of Shader build. GL Error: " + GL.GetError());
GL.UseProgram(0);
}
/// <summary>Setup OpenGL and load resources here.</summary>
/// <param name="e">Not used.</param>
protected override void OnLoad(EventArgs e)
{
this.VSync = VSyncMode.Off;
// Check for necessary capabilities:
string extensions = GL.GetString(StringName.Extensions);
if (!GL.GetString(StringName.Extensions).Contains("GL_ARB_shading_language"))
{
throw new NotSupportedException(String.Format("This example requires OpenGL 2.0. Found {0}. Aborting.",
GL.GetString(StringName.Version).Substring(0, 3)));
}
if (!extensions.Contains("GL_ARB_texture_compression") ||
!extensions.Contains("GL_EXT_texture_compression_s3tc"))
{
throw new NotSupportedException("This example requires support for texture compression. Aborting.");
}
int[] temp = new int[1];
GL.GetInteger(GetPName.MaxTextureImageUnits, out temp[0]);
Trace.WriteLine(temp[0] + " TMU's for Fragment Shaders found. (2 required)");
GL.GetInteger(GetPName.MaxVaryingFloats, out temp[0]);
Trace.WriteLine(temp[0] + " varying floats between VS and FS allowed. (6 required)");
GL.GetInteger(GetPName.MaxVertexUniformComponents, out temp[0]);
Trace.WriteLine(temp[0] + " uniform components allowed in Vertex Shader. (6 required)");
GL.GetInteger(GetPName.MaxFragmentUniformComponents, out temp[0]);
Trace.WriteLine(temp[0] + " uniform components allowed in Fragment Shader. (11 required)");
Trace.WriteLine("");
#region GL State
GL.ClearColor(0.2f, 0f, 0.4f, 0f);
GL.PointSize(10f);
GL.Disable(EnableCap.Dither);
GL.FrontFace(FrontFaceDirection.Ccw);
GL.PolygonMode(MaterialFace.Front, PolygonMode.Fill);
GL.PolygonMode(MaterialFace.Back, PolygonMode.Line);
#endregion GL State
#region Shaders
string LogInfo;
// Load&Compile Vertex Shader
using (StreamReader sr = new StreamReader(VertexShaderFilename))
{
VertexShaderObject = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(VertexShaderObject, sr.ReadToEnd( ));
GL.CompileShader(VertexShaderObject);
}
GL.GetShaderInfoLog(VertexShaderObject, out LogInfo);
if (LogInfo.Length > 0 && !LogInfo.Contains("hardware"))
{
Trace.WriteLine("Vertex Shader failed!\nLog:\n" + LogInfo);
}
else
{
Trace.WriteLine("Vertex Shader compiled without complaint.");
}
// Load&Compile Fragment Shader
using (StreamReader sr = new StreamReader(FragmentShaderFilename))
{
FragmentShaderObject = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(FragmentShaderObject, sr.ReadToEnd( ));
GL.CompileShader(FragmentShaderObject);
}
GL.GetShaderInfoLog(FragmentShaderObject, out LogInfo);
if (LogInfo.Length > 0 && !LogInfo.Contains("hardware"))
{
Trace.WriteLine("Fragment Shader failed!\nLog:\n" + LogInfo);
}
else
{
Trace.WriteLine("Fragment Shader compiled without complaint.");
}
// Link the Shaders to a usable Program
ProgramObject = GL.CreateProgram( );
GL.AttachShader(ProgramObject, VertexShaderObject);
GL.AttachShader(ProgramObject, FragmentShaderObject);
// must bind the attribute before linking
GL.BindAttribLocation(ProgramObject, AttribTangent, "AttributeTangent");
// link it all together
GL.LinkProgram(ProgramObject);
// flag ShaderObjects for delete when not used anymore
GL.DeleteShader(VertexShaderObject);
GL.DeleteShader(FragmentShaderObject);
GL.GetProgram(ProgramObject, GetProgramParameterName.LinkStatus, out temp[0]);
Trace.WriteLine("Linking Program (" + ProgramObject + ") " + ((temp[0] == 1) ? "succeeded." : "FAILED!"));
if (temp[0] != 1)
{
GL.GetProgramInfoLog(ProgramObject, out LogInfo);
Trace.WriteLine("Program Log:\n" + LogInfo);
}
GL.GetProgram(ProgramObject, GetProgramParameterName.ActiveAttributes, out temp[0]);
Trace.WriteLine("Program registered " + temp[0] + " Attributes. (Should be 4: Pos, UV, Normal, Tangent)");
Trace.WriteLine("Tangent attribute bind location: " + GL.GetAttribLocation(ProgramObject, "AttributeTangent"));
Trace.WriteLine("End of Shader build. GL Error: " + GL.GetError( ));
#endregion Shaders
#region Textures
TextureLoaderParameters.MagnificationFilter = TextureMagFilter.Linear;
TextureLoaderParameters.MinificationFilter = TextureMinFilter.LinearMipmapLinear;
TextureLoaderParameters.WrapModeS = TextureWrapMode.ClampToBorder;
TextureLoaderParameters.WrapModeT = TextureWrapMode.ClampToBorder;
TextureLoaderParameters.EnvMode = TextureEnvMode.Modulate;
ImageDDS.LoadFromDisk(TMU0_Filename, out TMU0_Handle, out TMU0_Target);
Trace.WriteLine("Loaded " + TMU0_Filename + " with handle " + TMU0_Handle + " as " + TMU0_Target);
ImageDDS.LoadFromDisk(TMU1_Filename, out TMU1_Handle, out TMU1_Target);
Trace.WriteLine("Loaded " + TMU1_Filename + " with handle " + TMU1_Handle + " as " + TMU1_Target);
#endregion Textures
Trace.WriteLine("End of Texture Loading. GL Error: " + GL.GetError( ));
Trace.WriteLine("");
}
float UniformOffsetY = 1.8f; // fractal vertical offset
#endregion private Fields
#region OnLoad
/// <summary>
/// Setup OpenGL and load resources here.
/// </summary>
/// <param name="e">Not used.</param>
protected override void OnLoad(EventArgs e)
{
// Check for necessary capabilities:
string version = GL.GetString(StringName.Version);
int major = (int)version[0];
int minor = (int)version[2];
if (major < 2)
{
MessageBox.Show("You need at least OpenGL 2.0 to run this example. Aborting.",
"GLSL not supported", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
this.Exit();
}
this.VSync = VSyncMode.On;
GL.Disable(EnableCap.Dither);
GL.ClearColor(0.2f, 0f, 0.4f, 0f);
// declare some variables for tracking which shader did compile, and which texture to use
string[] ShaderFilenames = new string[2];
ShaderFilenames[0] = "Data/Shaders/JuliaSet_SM3_FS.glsl";
ShaderFilenames[1] = "Data/Shaders/JuliaSet_SM2_FS.glsl";
byte CurrentOption = 0;
string LogInfo;
#region Shaders
// Load&Compile Vertex Shader
using (StreamReader sr = new StreamReader("Data/Shaders/JuliaSet_VS.glsl"))
{
VertexShaderObject = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(VertexShaderObject, sr.ReadToEnd());
GL.CompileShader(VertexShaderObject);
}
GL.GetShaderInfoLog(VertexShaderObject, out LogInfo);
if (LogInfo.Length > 0 && !LogInfo.Contains("hardware"))
{
Trace.WriteLine("Vertex Shader Log:\n" + LogInfo);
}
else
{
Trace.WriteLine("Vertex Shader compiled without complaint.");
}
// Load&Compile Fragment Shader
FragmentShaderObject = GL.CreateShader(ShaderType.FragmentShader);
do
{
using (StreamReader sr = new StreamReader(ShaderFilenames[CurrentOption]))
{
GL.ShaderSource(FragmentShaderObject, sr.ReadToEnd());
GL.CompileShader(FragmentShaderObject);
}
GL.GetShaderInfoLog(FragmentShaderObject, out LogInfo);
if (LogInfo.Length > 0 && !LogInfo.Contains("hardware"))
{
Trace.WriteLine("Compiling " + ShaderFilenames[CurrentOption] + " failed!\nLog:\n" + LogInfo);
}
else
{
Trace.WriteLine("Fragment Shader compiled without complaint.");
break;
}
if (++CurrentOption > 1)
{
MessageBox.Show("Neither SM2 nor SM3 Fragment Shader compiled successfully. Aborting.",
"Fatal Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.Exit();
}
} while (true);
// Link the Shaders to a usable Program
ProgramObject = GL.CreateProgram();
GL.AttachShader(ProgramObject, VertexShaderObject);
GL.AttachShader(ProgramObject, FragmentShaderObject);
GL.LinkProgram(ProgramObject);
// make current
GL.UseProgram(ProgramObject);
// Flag ShaderObjects for delete when app exits
GL.DeleteShader(VertexShaderObject);
GL.DeleteShader(FragmentShaderObject);
#endregion Shaders
#region Textures
// Load&Bind the 1D texture for color lookups
GL.ActiveTexture(TextureUnit.Texture0); // select TMU0
GL.GenTextures(1, out TextureObject);
GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureWrapS, (int)(TextureWrapMode)All.ClampToEdge);
using (Bitmap bitmap = new Bitmap("Data/Textures/JuliaColorTable.bmp"))
{
BitmapData data = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format24bppRgb);
GL.TexImage1D(TextureTarget.Texture1D, 0, PixelInternalFormat.Rgb8, data.Width, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgr,
PixelType.UnsignedByte, data.Scan0);
bitmap.UnlockBits(data);
}
#endregion Textures
Keyboard.KeyUp += KeyUp;
}
