public ImageWithCaption(string titleText, string captionText, string media)
: this(titleText, captionText)
{
image = new Texture(media);
imageVAO = Utilities.CreateQuad(Shaders.SimpleTexturedShader, Vector2.Zero, new Vector2(904, 410));
imageModelMatrix = Matrix4.CreateTranslation(new Vector3(72, 720 - 65 - 410, 0));
}
static void Main(string[] args)
{
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
Glut.glutInitWindowSize(width, height);
Glut.glutCreateWindow("OpenGL Tutorial");
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
Glut.glutKeyboardFunc(OnKeyboardDown);
Glut.glutKeyboardUpFunc(OnKeyboardUp);
Glut.glutCloseFunc(OnClose);
Glut.glutReshapeFunc(OnReshape);
Gl.Disable(EnableCap.DepthTest);
Gl.Enable(EnableCap.Blend);
Gl.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
program = new ShaderProgram(VertexShader, FragmentShader);
program.Use();
program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 10), Vector3.Zero, Vector3.Up));
program["light_direction"].SetValue(new Vector3(0, 0, 1));
program["enable_lighting"].SetValue(lighting);
glassTexture = new Texture("glass.bmp");
cube = new VBO<Vector3>(new Vector3[] {
new Vector3(1, 1, -1), new Vector3(-1, 1, -1), new Vector3(-1, 1, 1), new Vector3(1, 1, 1), // top
new Vector3(1, -1, 1), new Vector3(-1, -1, 1), new Vector3(-1, -1, -1), new Vector3(1, -1, -1), // bottom
new Vector3(1, 1, 1), new Vector3(-1, 1, 1), new Vector3(-1, -1, 1), new Vector3(1, -1, 1), // front face
new Vector3(1, -1, -1), new Vector3(-1, -1, -1), new Vector3(-1, 1, -1), new Vector3(1, 1, -1), // back face
new Vector3(-1, 1, 1), new Vector3(-1, 1, -1), new Vector3(-1, -1, -1), new Vector3(-1, -1, 1), // left
new Vector3(1, 1, -1), new Vector3(1, 1, 1), new Vector3(1, -1, 1), new Vector3(1, -1, -1) }); // right
cubeNormals = new VBO<Vector3>(new Vector3[] {
new Vector3(0, 1, 0), new Vector3(0, 1, 0), new Vector3(0, 1, 0), new Vector3(0, 1, 0),
new Vector3(0, -1, 0), new Vector3(0, -1, 0), new Vector3(0, -1, 0), new Vector3(0, -1, 0),
new Vector3(0, 0, 1), new Vector3(0, 0, 1), new Vector3(0, 0, 1), new Vector3(0, 0, 1),
new Vector3(0, 0, -1), new Vector3(0, 0, -1), new Vector3(0, 0, -1), new Vector3(0, 0, -1),
new Vector3(-1, 0, 0), new Vector3(-1, 0, 0), new Vector3(-1, 0, 0), new Vector3(-1, 0, 0),
new Vector3(1, 0, 0), new Vector3(1, 0, 0), new Vector3(1, 0, 0), new Vector3(1, 0, 0) });
cubeUV = new VBO<Vector2>(new Vector2[] {
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1) });
cubeQuads = new VBO<int>(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 }, BufferTarget.ElementArrayBuffer);
watch = System.Diagnostics.Stopwatch.StartNew();
Glut.glutMainLoop();
}
public ImageAndText(string titleText, string media, string[] bulletText)
: this(titleText, bulletText)
{
image = new Texture(media);
imageVAO = Utilities.CreateQuad(Shaders.SimpleTexturedShader, Vector2.Zero, new Vector2(441, 410));
imageModelMatrix = Matrix4.CreateTranslation(new Vector3(72, 720 - 227 - 410, 0));
}
static void Main(string[] args)
{
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
Glut.glutInitWindowSize(width, height);
Glut.glutCreateWindow("OpenGL Tutorial");
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
Glut.glutKeyboardFunc(OnKeyboardDown);
Glut.glutKeyboardUpFunc(OnKeyboardUp);
Glut.glutCloseFunc(OnClose);
Glut.glutReshapeFunc(OnReshape);
// enable blending and set to accumulate the star colors
Gl.Disable(EnableCap.DepthTest);
Gl.Enable(EnableCap.Blend);
Gl.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.One);
// create our shader program
program = new ShaderProgram(VertexShader, FragmentShader);
// set up the projection and view matrix
program.Use();
program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 20), Vector3.Zero, Vector3.Up));
// load the star texture
starTexture = new Texture("star.bmp");
// each star is simply a quad
star = new VBO<Vector3>(new Vector3[] { new Vector3(-1, -1, 0), new Vector3(1, -1, 0), new Vector3(1, 1, 0), new Vector3(-1, 1, 0) });
starUV = new VBO<Vector2>(new Vector2[] { new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1) });
starQuads = new VBO<int>(new int[] { 0, 1, 2, 0, 2, 3 }, BufferTarget.ElementArrayBuffer);
// create 50 stars for this tutorial
int numStars = 50;
for (int i = 0; i < numStars; i++)
{
stars.Add(new Star(0, (float)i / numStars * 4f, new Vector3(generator.NextDouble(), generator.NextDouble(), generator.NextDouble())));
}
font = new BMFont("font24.fnt", "font24.png");
fontProgram = new ShaderProgram(BMFont.FontVertexSource, BMFont.FontFragmentSource);
fontProgram.Use();
fontProgram["ortho_matrix"].SetValue(Matrix4.CreateOrthographic(width, height, 0, 1000));
fontProgram["color"].SetValue(new Vector3(1, 1, 1));
information = font.CreateString(fontProgram, "OpenGL C# Tutorial 10");
watch = System.Diagnostics.Stopwatch.StartNew();
Glut.glutMainLoop();
}
public Billboard(ShaderProgram program, Texture texture, Vector3[] locations, Vector3[] colors)
{
this.Program = program;
this.Texture = texture;
int[] elements = new int[locations.Length];
for (int i = 0; i < elements.Length; i++) elements[i] = i;
this.billboard = new VAO(program, new VBO<Vector3>(locations), new VBO<Vector3>(colors), new VBO<int>(elements));
this.billboard.DrawMode = BeginMode.Points;
this.billboard.DisposeChildren = true;
this.Color = new Vector4(1, 1, 1, 1);
}
public TwoImages(string titleText, string media1, string media2)
{
title = new Text(Text.FontSize._72pt, titleText, Common.TitleColor);
title.ModelMatrix = Matrix4.CreateTranslation(new Vector3(80, 720 - 120, 0));
image1 = new Texture(media1);
image1VAO = Utilities.CreateQuad(Shaders.SimpleTexturedShader, Vector2.Zero, new Vector2(441, 410));
image1ModelMatrix = Matrix4.CreateTranslation(new Vector3(72, 720 - 227 - 410, 0));
image2 = new Texture(media2);
image2VAO = Utilities.CreateQuad(Shaders.SimpleTexturedShader, Vector2.Zero, new Vector2(441, 410));
image2ModelMatrix = Matrix4.CreateTranslation(new Vector3(535, 720 - 227 - 410, 0));
}
static void Main(string[] args)
{
// create an OpenGL window
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
Glut.glutInitWindowSize(width, height);
Glut.glutCreateWindow("OpenGL Tutorial");
// provide the Glut callbacks that are necessary for running this tutorial
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
Glut.glutCloseFunc(OnClose);
// enable depth testing to ensure correct z-ordering of our fragments
Gl.Enable(EnableCap.DepthTest);
// compile the shader program
program = new ShaderProgram(VertexShader, FragmentShader);
// set the view and projection matrix, which are static throughout this tutorial
program.Use();
program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 10), Vector3.Zero, Vector3.Up));
// load a crate texture
crateTexture = new Texture("crate.jpg");
// create a crate with vertices and UV coordinates
cube = new VBO<Vector3>(new Vector3[] {
new Vector3(1, 1, -1), new Vector3(-1, 1, -1), new Vector3(-1, 1, 1), new Vector3(1, 1, 1),
new Vector3(1, -1, 1), new Vector3(-1, -1, 1), new Vector3(-1, -1, -1), new Vector3(1, -1, -1),
new Vector3(1, 1, 1), new Vector3(-1, 1, 1), new Vector3(-1, -1, 1), new Vector3(1, -1, 1),
new Vector3(1, -1, -1), new Vector3(-1, -1, -1), new Vector3(-1, 1, -1), new Vector3(1, 1, -1),
new Vector3(-1, 1, 1), new Vector3(-1, 1, -1), new Vector3(-1, -1, -1), new Vector3(-1, -1, 1),
new Vector3(1, 1, -1), new Vector3(1, 1, 1), new Vector3(1, -1, 1), new Vector3(1, -1, -1) });
cubeUV = new VBO<Vector2>(new Vector2[] {
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1) });
cubeQuads = new VBO<int>(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 }, BufferTarget.ElementArrayBuffer);
watch = System.Diagnostics.Stopwatch.StartNew();
Glut.glutMainLoop();
}
/// <summary>
/// Creates a bitmap font object, which is created from a h by v array of bitmap characters.
/// </summary>
/// <param name="FontTexture">A grid of h*v characters ordered by ASCII number.</param>
public BitmapFont(Texture FontTexture, int h, int v)
{
if (FontTexture.Size.Width % h != 0) throw new Exception("FontTexture is not a width that is divisible by h.");
if (FontTexture.Size.Height % v != 0) throw new Exception("FontTexture is not a height that is divisible by v.");
this.FontTexture = FontTexture;
float delx = (float)FontTexture.Size.Width / h;
float dely = (float)FontTexture.Size.Height / v;
Character = new UVPair[h * v];
for (int x = 0; x < h; x++)
{
for (int y = 0; y < v; y++)
{
Character[x + y * h] = new UVPair(
new Vector2(x * delx / FontTexture.Size.Width, 1 - (y + 1) * delx / FontTexture.Size.Height),
new Vector2((x + 1) * delx / FontTexture.Size.Width, 1 - (y * delx + 1) / FontTexture.Size.Height));
}
}
}
/// <summary>
/// Copy this GraphicsSurface color buffer into a buffer.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/>
/// </param>
/// <param name="attachment">
/// </param>
/// <param name="x">
/// A <see cref="Int32"/> that specify the x coordinate of the lower left corder of the rectangle area to read.
/// </param>
/// <param name="y">
/// A <see cref="Int32"/> that specify the y coordinate of the lower left corder of the rectangle area to read.
/// </param>
/// <param name="texture">
/// </param>
/// <param name="level">
/// </param>
public void CopyColorBuffer(GraphicsContext ctx, uint attachment, uint x, uint y, ref Texture texture, uint level)
{
CopyBuffer(ctx, (ReadBufferMode)(Gl.COLOR_ATTACHMENT0 + (int)attachment), x, y, ref texture, level);
}
/// <summary>
/// Set uniform state variable (sampler1D, sampler2D, sampler3D, samplerCube variable).
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> used for operations.
/// </param>
/// <param name="uniformName">
/// A <see cref="String"/> that specify the variable name in the shader source.
/// </param>
/// <param name="tex">
/// A <see cref="Texture"/> holding the uniform variabile data (the texture name).
/// </param>
/// <param name="texUnit">
/// A <see cref="Int32"/> that specify the texture unit processing the texture <paramref name="tex"/>.
/// </param>
public void SetUniform(GraphicsContext ctx, string uniformName, Texture tex, uint texUnit)
{
if (ctx == null)
throw new ArgumentNullException("ctx");
UniformBinding uniform = GetUniform(uniformName);
if (tex == null)
throw new ArgumentNullException("tex");
if (tex.Exists(ctx) == false)
throw new ArgumentException("not exists", "tex");
CheckProgramBinding();
CheckUniformType(uniform, tex.SamplerType);
// Activate texture unit
Gl.ActiveTexture(Gl.TEXTURE0 + (int)texUnit);
// Bind texture (on active texture unit)
tex.Bind(ctx);
// Apply texture parameters
tex.ApplyParameters(ctx);
// Set uniform value (sampler)
// Cast to Int32 since the sampler type can be set only with glUniform2i
Gl.Uniform1(uniform.Location, (int)texUnit);
// Validate program
Validate();
}
/// <summary>
/// Set uniform state variable (sampler1D, sampler2D, sampler3D, samplerCube variable).
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> used for operations.
/// </param>
/// <param name="uniformName">
/// A <see cref="String"/> that specify the variable name in the shader source.
/// </param>
/// <param name="tex">
/// A <see cref="Texture"/> holding the uniform variabile data (the texture name).
/// </param>
public void SetUniform(GraphicsContext ctx, string uniformName, Texture tex)
{
SetUniform(ctx, uniformName, tex, mTexActiveUnit++);
}
public static void Init()
{
BackgroundQuad = Utilities.CreateQuad(Shaders.SimpleTexturedShader);
BackgroundTexture = new Texture("media/background.png");
BulletTexture = new Texture("media/bullet.png");
BulletQuad = Utilities.CreateQuad(Shaders.SimpleTexturedShader, Vector2.Zero, new Vector2(24, 24));
VBO<Vector3> vertices = new VBO<Vector3>(new Vector3[] { new Vector3(0, 0, 0), new Vector3(1, 0, 0), new Vector3(1, 1, 0), new Vector3(0, 1, 0) });
VBO<int> indices = new VBO<int>(new int[] { 0, 1, 2, 3, 0 }, BufferTarget.ElementArrayBuffer);
BoxQuad = new VAO(Shaders.SimpleColoredShader, vertices, indices);
BoxQuad.DrawMode = BeginMode.LineStrip;
indices = new VBO<int>(new int[] { 0, 1, 2, 3 }, BufferTarget.ElementArrayBuffer);
StencilQuad = new VAO(Shaders.SimpleColoredShader, vertices, indices);
StencilQuad.DrawMode = BeginMode.Quads;
vertices = new VBO<Vector3>(new Vector3[] { new Vector3(0.5, -0.01, 0), new Vector3(0.5, 1.01, 0), new Vector3(-0.01, 0.5, 0), new Vector3(1.01, 0.5, 0) });
indices = new VBO<int>(new int[] { 2, 3, 0, 1 }, BufferTarget.ElementArrayBuffer);
CrosshairVAO = new VAO(Shaders.SimpleColoredShader, vertices, indices);
CrosshairVAO.DrawMode = BeginMode.Lines;
Shaders.FontShader.Use();
Shaders.FontShader["viewMatrix"].SetValue(Matrix4.Identity);
Shaders.SimpleColoredShader.Use();
Shaders.SimpleColoredShader["viewMatrix"].SetValue(Matrix4.Identity);
}
static void Main(string[] args)
{
timefromstart = System.Diagnostics.Stopwatch.StartNew();
Console.WriteLine("Initializing GLUT - {0}s", getTimeFromStart().ToString());
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
Glut.glutInitWindowSize(width, height);
Glut.glutCreateWindow("kVoxGame");
Console.WriteLine("GLUT window created - {0}s", getTimeFromStart().ToString());
//Callbacks
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
//Mouse
Glut.glutMouseFunc(OnMouse);
Glut.glutMotionFunc(OnMove);
//Keyboard
Glut.glutKeyboardFunc(OnKeyboardDown);
Glut.glutKeyboardUpFunc(OnKeyboardUp);
Console.WriteLine("GLUT callbacks binded - {0}s", getTimeFromStart().ToString());
Gl.Enable(EnableCap.DepthTest);
Gl.Enable(EnableCap.Blend);
Gl.Enable(EnableCap.Multisample);
Gl.Enable(EnableCap.SampleAlphaToCoverage);
Gl.Enable(EnableCap.FragmentLightingSgix);
Gl.Enable(EnableCap.CullFace);
Console.WriteLine("GL Enables enabled :D - {0}s", getTimeFromStart().ToString());
skydomeTexture = new Texture("skydome.jpg");
//Gl.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
// create main shader program
terrainSP = new ShaderProgram(terrainVS, terrainFS);
terrainSP.Use();
terrainSP["color"].SetValue(new Vector3(0, 0.8, 0));
projectionMatrix = Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f);
terrainSP["projection_matrix"].SetValue(projectionMatrix);
terrainSP["model_matrix"].SetValue(Matrix4.CreateTranslation(new Vector3(0, 0, 0)) * Matrix4.CreateRotation(new Vector3(0, 0, 0), 0.0f));
Console.WriteLine("Shader program (main) compiled and data injected - {0}s", getTimeFromStart().ToString());
// create main skybox program
skyboxSP = new ShaderProgram(skyboxVS, skyboxFS);
skyboxSP.Use();
skyboxSP["color"].SetValue(new Vector3(0.2, 1.0, 1.0));
skyboxSP["resolution"].SetValue(new Vector2(width, height));
projectionMatrix = Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f);
skyboxSP["projection_matrix"].SetValue(projectionMatrix);
skyboxSP["model_matrix"].SetValue(Matrix4.CreateTranslation(new Vector3(0, 0, 0)) * Matrix4.CreateRotation(new Vector3(0, 0, 0), 0.0f));
Console.WriteLine("Shader program (skybox) compiled and data injected - {0}s", getTimeFromStart().ToString());
//Setup camera
camera = new Camera(new Vector3(0, 0, 10), Quaternion.Identity);
camera.SetDirection(new Vector3(0, 0, -1));
Console.WriteLine("Cam setup complete - {0}s", getTimeFromStart().ToString());
watch = System.Diagnostics.Stopwatch.StartNew();
chunks = new VoxelChunk[4];
//instance few voxel chunks
chunks[0] = new VoxelChunk(0,0);
chunks[1] = new VoxelChunk(0, 32);
chunks[2] = new VoxelChunk(32, 0);
chunks[3] = new VoxelChunk(32, 32);
Console.WriteLine("Chunks added to array - {0}s", getTimeFromStart().ToString());
//init frustum
frustum = new Frustum();
frustum.UpdateFrustum(projectionMatrix, camera.ViewMatrix);
Console.WriteLine("starting main GLUT loop - {0}s", getTimeFromStart().ToString());
Glut.glutMainLoop();
}
public Billboard(ShaderProgram program, Texture texture, Vector3 location, float size)
: this(program, texture, new Vector3[] { location }, new Vector3[] { new Vector3(1, 1, 1) })
{
}
static void Main(string[] args)
{
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH | Glut.GLUT_MULTISAMPLE); // multisampling makes things beautiful!
Glut.glutInitWindowSize(width, height);
Glut.glutCreateWindow("OpenGL Tutorial");
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
Glut.glutKeyboardFunc(OnKeyboardDown);
Glut.glutKeyboardUpFunc(OnKeyboardUp);
Glut.glutCloseFunc(OnClose);
Glut.glutReshapeFunc(OnReshape);
// enable blending and set to accumulate the star colors
Gl.Enable(EnableCap.Blend);
Gl.Enable(EnableCap.ProgramPointSize);
Gl.Enable(EnableCap.Multisample);
Gl.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.One);
// create our shader program
program = new ShaderProgram(VertexShader, FragmentShader);
// set up the projection and view matrix
program.Use();
program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 20), Vector3.Zero, Vector3.Up));
program["model_matrix"].SetValue(Matrix4.Identity);
program["static_colors"].SetValue(false);
// load the particle texture
particleTexture = new Texture("star.bmp");
// set up the particlePoints VBO, which will stay constant
int[] points = new int[particleCount];
for (int i = 0; i < points.Length; i++) points[i] = i;
particlePoints = new VBO<int>(points, BufferTarget.ElementArrayBuffer);
// set up the particleColors, which we'll just keep static
Vector3[] colors = new Vector3[particleCount];
for (int i = 0; i < colors.Length; i++) colors[i] = new Vector3(generator.NextDouble(), generator.NextDouble(), generator.NextDouble());
particleColors = new VBO<Vector3>(colors);
// build up our first batch of 1000 particles and 1000 static colors
for (int i = 0; i < particleCount; i++) particles.Add(new Particle(Vector3.Zero, 0));
// load the bitmap font for this tutorial
font = new BMFont("font24.fnt", "font24.png");
fontProgram = new ShaderProgram(BMFont.FontVertexSource, BMFont.FontFragmentSource);
fontProgram.Use();
fontProgram["ortho_matrix"].SetValue(Matrix4.CreateOrthographic(width, height, 0, 1000));
fontProgram["color"].SetValue(new Vector3(1, 1, 1));
information = font.CreateString(fontProgram, "OpenGL C# Tutorial 12");
watch = System.Diagnostics.Stopwatch.StartNew();
Glut.glutMainLoop();
}
static void Main(string[] args)
{
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
Glut.glutInitWindowSize(width, height);
Glut.glutCreateWindow("OpenGL Tutorial");
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
Glut.glutKeyboardFunc(OnKeyboardDown);
Glut.glutKeyboardUpFunc(OnKeyboardUp);
Glut.glutCloseFunc(OnClose);
Glut.glutReshapeFunc(OnReshape);
// enable blending and set to accumulate the star colors
Gl.Enable(EnableCap.DepthTest);
Gl.Enable(EnableCap.Blend);
// create our shader program
program = new ShaderProgram(VertexShader, FragmentShader);
// set up the projection and view matrix
program.Use();
program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 20), Vector3.Zero, Vector3.Up));
program["model_matrix"].SetValue(Matrix4.Identity);
// load the flag texture
flagTexture = new Texture("flag.png");
// create the flag, which is just a plane with a certain number of segments
List<Vector3> vertices = new List<Vector3>();
List<Vector2> uvs = new List<Vector2>();
List<int> triangles = new List<int>();
for (int x = 0; x < 40; x++)
{
for (int y = 0; y < 40; y++)
{
vertices.Add(new Vector3((x - 20) / 5.0, (y - 20) / 10.0, 0));
uvs.Add(new Vector2(x / 39.0, 1 - y / 39.0));
if (y == 39 || x == 39) continue;
triangles.Add(x * 40 + y);
triangles.Add((x + 1) * 40 + y);
triangles.Add((x + 1) * 40 + y + 1);
triangles.Add(x * 40 + y);
triangles.Add((x + 1) * 40 + y + 1);
triangles.Add(x * 40 + y + 1);
}
}
flagVertices = new VBO<Vector3>(vertices.ToArray());
flagUVs = new VBO<Vector2>(uvs.ToArray());
flagTriangles = new VBO<int>(triangles.ToArray(), BufferTarget.ElementArrayBuffer);
// load the bitmap font for this tutorial
font = new BMFont("font24.fnt", "font24.png");
fontProgram = new ShaderProgram(BMFont.FontVertexSource, BMFont.FontFragmentSource);
fontProgram.Use();
fontProgram["ortho_matrix"].SetValue(Matrix4.CreateOrthographic(width, height, 0, 1000));
fontProgram["color"].SetValue(new Vector3(1, 1, 1));
information = font.CreateString(fontProgram, "OpenGL C# Tutorial 11");
watch = System.Diagnostics.Stopwatch.StartNew();
Glut.glutMainLoop();
}
public RenderTextureAttachment(Texture texture)
: this(texture, 0)
{
}
static void Main(string[] args)
{
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH | Glut.GLUT_MULTISAMPLE); // multisampling makes things beautiful!
Glut.glutInitWindowSize(width, height);
Glut.glutCreateWindow("OpenGL Tutorial");
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
Glut.glutKeyboardFunc(OnKeyboardDown);
Glut.glutKeyboardUpFunc(OnKeyboardUp);
Glut.glutCloseFunc(OnClose);
Glut.glutReshapeFunc(OnReshape);
// add our mouse callbacks for this tutorial
Glut.glutMouseFunc(OnMouse);
Glut.glutMotionFunc(OnMove);
Gl.Enable(EnableCap.DepthTest);
Gl.Enable(EnableCap.Blend);
Gl.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
// create our shader program
program = new ShaderProgram(VertexShader, FragmentShader);
// create our camera
camera = new Camera(new Vector3(0, 0, 10), Quaternion.Identity);
camera.SetDirection(new Vector3(0, 0, -1));
// set up the projection and view matrix
program.Use();
program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
//program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 10), Vector3.Zero, Vector3.Up));
program["light_direction"].SetValue(new Vector3(0, 0, 1));
program["enable_lighting"].SetValue(lighting);
program["normalTexture"].SetValue(1);
program["enable_mapping"].SetValue(normalMapping);
brickDiffuse = new Texture("AlternatingBrick-ColorMap.png");
brickNormals = new Texture("AlternatingBrick-NormalMap.png");
Vector3[] vertices = new Vector3[] {
new Vector3(1, 1, -1), new Vector3(-1, 1, -1), new Vector3(-1, 1, 1), new Vector3(1, 1, 1), // top
new Vector3(1, -1, 1), new Vector3(-1, -1, 1), new Vector3(-1, -1, -1), new Vector3(1, -1, -1), // bottom
new Vector3(1, 1, 1), new Vector3(-1, 1, 1), new Vector3(-1, -1, 1), new Vector3(1, -1, 1), // front face
new Vector3(1, -1, -1), new Vector3(-1, -1, -1), new Vector3(-1, 1, -1), new Vector3(1, 1, -1), // back face
new Vector3(-1, 1, 1), new Vector3(-1, 1, -1), new Vector3(-1, -1, -1), new Vector3(-1, -1, 1), // left
new Vector3(1, 1, -1), new Vector3(1, 1, 1), new Vector3(1, -1, 1), new Vector3(1, -1, -1) };
cube = new VBO<Vector3>(vertices);
Vector2[] uvs = new Vector2[] {
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1) };
cubeUV = new VBO<Vector2>(uvs);
List<int> triangles = new List<int>();
for (int i = 0; i < 6; i++)
{
triangles.Add(i * 4);
triangles.Add(i * 4 + 1);
triangles.Add(i * 4 + 2);
triangles.Add(i * 4);
triangles.Add(i * 4 + 2);
triangles.Add(i * 4 + 3);
}
cubeTriangles = new VBO<int>(triangles.ToArray(), BufferTarget.ElementArrayBuffer);
Vector3[] normals = Geometry.CalculateNormals(vertices, triangles.ToArray());
cubeNormals = new VBO<Vector3>(normals);
Vector3[] tangents = CalculateTangents(vertices, normals, triangles.ToArray(), uvs);
cubeTangents = new VBO<Vector3>(tangents);
// load the bitmap font for this tutorial
font = new BMFont("font24.fnt", "font24.png");
fontProgram = new ShaderProgram(BMFont.FontVertexSource, BMFont.FontFragmentSource);
fontProgram.Use();
fontProgram["ortho_matrix"].SetValue(Matrix4.CreateOrthographic(width, height, 0, 1000));
fontProgram["color"].SetValue(new Vector3(1, 1, 1));
information = font.CreateString(fontProgram, "OpenGL C# Tutorial 15");
watch = System.Diagnostics.Stopwatch.StartNew();
Glut.glutMainLoop();
}
protected RenderTextureAttachment(Texture texture, uint textureLevel, TextureTarget textureTarget)
{
if (texture == null)
throw new ArgumentNullException("texture");
Texture = texture;
Texture.IncRef();
TextureLevel = textureLevel;
TextureTarget = textureTarget;
}
public RenderTextureAttachment(Texture texture, uint textureLevel)
{
if (texture == null)
throw new ArgumentNullException("texture");
Texture = texture;
Texture.IncRef();
TextureLevel = textureLevel;
// Derive texture target from Texture
TextureTarget = Texture.TextureTarget;
}
/// <summary>
/// Copy this GraphicsSurface color buffer into a buffer.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> which is bound to this GraphicsSurface.
/// </param>
/// <param name="rBuffer">
/// A <see cref="ReadBufferMode"/> that specify the read buffer where the colors are read from.
/// </param>
/// <param name="x">
/// A <see cref="Int32"/> that specify the x coordinate of the lower left corder of the rectangle area to read.
/// </param>
/// <param name="y">
/// A <see cref="Int32"/> that specify the y coordinate of the lower left corder of the rectangle area to read.
/// </param>
/// <param name="texture">
/// A <see cref="Texture"/> that will hold the buffer data.
/// </param>
/// <param name="level">
/// The level of the texture <paramref name="texture"/> to be written.
/// </param>
/// <returns>
/// It returns an <see cref="Image"/> representing the current read buffer <paramref name="rBuffer"/>.
/// </returns>
protected void CopyBuffer(GraphicsContext ctx, ReadBufferMode rBuffer, uint x, uint y, ref Texture texture, uint level)
{
if (texture == null)
throw new ArgumentNullException("texture");
if (texture.Exists(ctx) == false)
throw new ArgumentException("not exists", "texture");
if ((x + texture.Width > Width) || (y + texture.Height > Height))
throw new ArgumentException("specified region lies outside the GraphicsSurface");
// Bind for reading
BindRead(ctx);
// Set for reading
Gl.ReadBuffer(rBuffer);
// Copy pixels from read buffer to texture
Gl.CopyTexImage2D(texture.TextureTarget, (int)level, Pixel.GetGlInternalFormat(texture.PixelLayout, ctx), (int)x, (int)y, (int)texture.Width, (int)texture.Height, 0);
// Unbind from reading
UnbindRead(ctx);
// Reset read configuration
Gl.ReadBuffer(Gl.NONE);
}
/// <summary>
/// Bind a named texture to a texturing target
/// </summary>
/// <param name="Texture">Specifies the texture.</param>
public static void BindTexture(Texture Texture)
{
Gl.BindTexture(Texture.TextureTarget, Texture.TextureID);
}