private void OnLoad(object sender, EventArgs e)
{
// initialize shader (load sources, create/compile/link shader program, error checking)
// when using the factory method the shader sources are retrieved from the ShaderSourceAttributes
_program = ProgramFactory.Create<ExampleProgram>();
// this program will be used all the time so just activate it once and for all
_program.Use();
// create vertices for a triangle
var vertices = new[] { new Vector3(-1,-1,0), new Vector3(1,-1,0), new Vector3(0,1,0) };
// create buffer object and upload vertex data
_vbo = new Buffer<Vector3>();
_vbo.Init(BufferTarget.ArrayBuffer, vertices);
// create and bind a vertex array
_vao = new VertexArray();
_vao.Bind();
// set up binding of the shader variable to the buffer object
_vao.BindAttribute(_program.InPosition, _vbo);
// set camera position
Camera.DefaultState.Position = new Vector3(0,0,3);
Camera.ResetToDefault();
// set a nice clear color
GL.ClearColor(Color.MidnightBlue);
}
protected void OnLoad(object sender, EventArgs e)
{
// load textures into array
for (var i = 0; i < _stateTextures.Length; i++)
{
using (var bitmap = new Bitmap(Path.Combine("Data/Textures/", _stateTextures[i])))
{
bitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);
if (_textureArray == null) BitmapTexture.CreateCompatible(bitmap, out _textureArray, _stateTextures.Length, 1);
_textureArray.LoadBitmap(bitmap, i);
}
}
// initialize buffer
var field = new Minefield[FieldWidth*FieldHeight];
for (var i = 0; i < field.Length; i++)
{
field[i] = new Minefield(i%FieldWidth, i/FieldHeight, i%_stateTextures.Length);
}
_buffer = new Buffer<Minefield>();
_buffer.Init(BufferTarget.ArrayBuffer, field);
// load program
_gridProgram = ProgramFactory.Create<TextureGridProgram>();
_gridProgram.Use();
// bind the texture and set uniform
_gridProgram.TextureData.BindTexture(TextureUnit.Texture0, _textureArray);
// set up vertex array and attributes
_vao = new VertexArray();
_vao.Bind();
_vao.BindAttribute(_gridProgram.InPosition, _buffer);
_vao.BindAttribute(_gridProgram.InTexture, _buffer, 8);
// set nice clear color
GL.ClearColor(Color.MidnightBlue);
// initialize camera position
Camera.DefaultState.Position = new Vector3(0, 5, 15);
Camera.ResetToDefault();
}
protected void OnLoad(object sender, EventArgs eventArgs)
{
VSync = VSyncMode.Off;
// Check for necessary capabilities:
var 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.");
}
var 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("");
// load textures
TextureLoaderParameters.MagnificationFilter = TextureMagFilter.Linear;
TextureLoaderParameters.MinificationFilter = TextureMinFilter.LinearMipmapLinear;
TextureLoaderParameters.WrapModeS = TextureWrapMode.ClampToBorder;
TextureLoaderParameters.WrapModeT = TextureWrapMode.ClampToBorder;
TextureLoaderParameters.EnvMode = TextureEnvMode.Modulate;
uint handle;
TextureTarget target;
ImageDDS.LoadFromDisk(TextureDiffuseHeightFilename, out handle, out target);
_textureDiffuseHeight = TextureFactory.AquireTexture2D((int) handle);
Trace.WriteLine("Loaded " + TextureDiffuseHeightFilename + " with handle " + handle + " as " + target);
ImageDDS.LoadFromDisk(TextureNormalGlossFilename, out handle, out target);
_textureNormalGloss = TextureFactory.AquireTexture2D((int) handle);
Trace.WriteLine("Loaded " + TextureNormalGlossFilename + " with handle " + handle + " as " + target);
Trace.WriteLine("End of Texture Loading. GL Error: " + GL.GetError());
Trace.WriteLine("");
// initialize buffer
var normal = Vector3.UnitZ;
var tangent = Vector3.UnitX;
var vertices = new[]
{
new Vertex
{
Position = new Vector3(-1,-1,0),
TexCoord = new Vector2(0,0),
Normal = normal,
Tangent = tangent
},
new Vertex
{
Position = new Vector3(1,-1,0),
TexCoord = new Vector2(1,0),
Normal = normal,
Tangent = tangent
},
new Vertex
{
Position = new Vector3(-1,1,0),
TexCoord = new Vector2(0,1),
Normal = normal,
Tangent = tangent
},
new Vertex
{
Position = new Vector3(1,1,0),
TexCoord = new Vector2(1,1),
Normal = normal,
Tangent = tangent
}
};
_buffer = new Buffer<Vertex>();
_buffer.Init(BufferTarget.ArrayBuffer, vertices);
// load shader
_program = ProgramFactory.Create<ParallaxProgram>();
_program.Use();
// set up vertex array
_vao = new VertexArray();
_vao.Bind();
// bind vertex attributes
// the buffer layout is defined by the Vertex struct:
// data X Y Z NX NY NZ TX TY TZ U V *next vertex*
// offset 0 4 8 12 16 20 24 28 32 36 40 44
// having to work with offsets could be prevented by using seperate buffer objects for each attribute,
// but that might reduce performance and can get annoying as well.
// performance increase could also be achieved by improving coherent read access
// by padding the struct so that each attribute begins at a multiple of 16 bytes, i.e. 4-floats
// because the GPU can then read all 4 floats at once. I did not do that here to keep it simple.
_vao.BindAttribute(_program.InPosition, _buffer);
_vao.BindAttribute(_program.InNormal, _buffer, 12);
_vao.BindAttribute(_program.InTangent, _buffer, 24);
_vao.BindAttribute(_program.InTexCoord, _buffer, 36);
// set camera position
Camera.DefaultState.Position = new Vector3(0,0,3);
Camera.ResetToDefault();
// set 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);
}
private void OnLoad(object sender, EventArgs e)
{
// load texture from file
using (var bitmap = new Bitmap("Data/Textures/checker.jpg"))
{
BitmapTexture.CreateCompatible(bitmap, out _texture);
_texture.LoadBitmap(bitmap);
}
_texture.GenerateMipMaps();
// initialize sampler
_sampler = new Sampler();
_sampler.SetWrapMode(TextureWrapMode.Repeat);
// create vertex data for a big plane
const int a = 10;
const int b = 10;
var vertices = new[]
{
new Vertex(-a, 0,-a, 0, 0),
new Vertex( a, 0,-a, b, 0),
new Vertex(-a, 0, a, 0, b),
new Vertex( a, 0, a, b, b)
};
// create buffer object and upload vertex data
_vbo = new Buffer<Vertex>();
_vbo.Init(BufferTarget.ArrayBuffer, vertices);
// initialize shader
_program = ProgramFactory.Create<SimpleTextureProgram>();
// activate shader program
_program.Use();
// bind sampler
_sampler.Bind(TextureUnit.Texture0);
// bind texture
_program.Texture.BindTexture(TextureUnit.Texture0, _texture);
// which is equivalent to
//_program.Texture.Set(TextureUnit.Texture0);
//_texture.Bind(TextureUnit.Texture0);
// set up vertex array and attributes
_vao = new VertexArray();
_vao.Bind();
// memory layout of our data is XYZUVXYZUV...
// the buffer abstraction knows the total size of one "pack" of vertex data
// and if a vertex attribute is bound without further arguments the first N elements are taken from each pack
// where N is provided via the VertexAttribAttribute on the program property:
_vao.BindAttribute(_program.InPosition, _vbo);
// if data should not be taken from the start of each pack, the offset must be given in bytes
// to reach the texture coordinates UV the XYZ coordinates must be skipped, that is 3 floats, i.e. an offset of 12 bytes is needed
_vao.BindAttribute(_program.InTexCoord, _vbo, 12);
// if needed all the available arguments can be specified manually, e.g.
//_vao.BindAttribute(_program.InTexCoord, _vbo, 2, VertexAttribPointerType.Float, Marshal.SizeOf(typeof(Vertex)), 12, false);
// set default camera
Camera.DefaultState.Position = new Vector3(0, 0.5f, 3);
Camera.ResetToDefault();
// set a nice clear color
GL.ClearColor(Color.MidnightBlue);
}