A wild engine appears!

void Foobar()
{
	RN::MetaClass *meta = RN::Catalogue::GetSharedInstance()->GetClassWithName("RN::Entity");
	RN::Object *object = meta->Construct();

	if(object->IsKindOfClass(RN::Array::MetaClass()))
	{
		throw "If you run into this, hide in your basement and good luck survivng the apocalypse";
	}

	object->SetValueForKey(RN::Model::WithFile("myModel"), RNCSTR("model"));
}

SceneNode player = new SceneNode();
player.Transform.LocalPosition = new Vector3(0, 3, 0);
player.Components.Add<CharacterController>();
player.Components.Add<Renderer>().Model = Game.Assets.Load<Model>("models/character");
player.Components.Add<PlayerInput>();
player.Parent = this.scene.Root;

SceneNode swirl = new SceneNode();
swirl.Transform.LocalPosition = new Vector3(2, 0, 0);
swirl.Components.Add<Scriptable>().Script =
    @"function update(self, time)
        self.Node.Transform:Rotate(0, 60 * time.DeltaTime, 5 * time.DeltaTime)
    end";
swirl.Parent = player;

SceneNode light = new SceneNode();
light.Components.Add<PointLight>().Color = Color.Red;
light.Parent = swirl;

-- We compile with GLSL Version 3.3
shader.version = "330"

-- Add a global shader source file that is accessible from all shaders:
shader.add
{
	type = "global",
	source = 
[[
	uniform mat4 matWorld;
	uniform mat4 matView;
	uniform mat4 matProjection;
	uniform sampler2D meshDiffuseTexture;
]]
}

-- Add a vertex shader. The input variables and layout is specified by the input entry
shader.add
{
	type = "vertex",
	input = "mesh",
	source = 
[[
	out vec2 uv;

	void main()
	{
		vec4 pos = vec4(vertexPosition, 1);
		gl_Position = matProjection * matView * matWorld * pos;
		
		uv = vertexUV;
	}
]]
}

-- Add a fragment shader. Simple alpha-testing shader.
shader.add
{
	type = "fragment",
	source = 
[[
	layout(location = 0) out vec4 color;
	in vec2 uv;
	void main()
	{
		color = texture(meshDiffuseTexture, uv);
		if(color.a < 0.5f) discard;
	}
]]
}

// Select the default shader:
CompiledShader cs = shader.Select();

// Bind it!
cs.Bind();

// Select the shader with class modifier:
CompiledShader cs = shader.Select("DeferredRenderer");
// Bind it (again)
cs.Bind();

// Create a custom fragment shader
var geometryPixelShader = new ShaderFragment(ShaderType.FragmentShader, geomPixSource);

// Select the shader with class and override the pixel shader.
CompiledShader cs = shader.Select("DeferredRenderer", geometryPixelShader);

// Should be known already
cs.Bind();

using Awesomium.Core;
using OpenTK;
using OpenTK.Graphics.OpenGL4;
using OpenWorld.Engine;
using System;

namespace WebDemo
{
	class Program : Game
	{
		static void Main(string[] args)
		{
			Program pgm = new Program();
			pgm.Run();
		}

		protected override PresentationParameters GetPresentationParameters()
		{
			var def = base.GetPresentationParameters();
			def.Title = "OpenWorld goes Web";
			return def;
		}

		Texture2D webTexture;
		WebSession session;
		WebView view;

		protected override void OnLoad()
		{
			base.OnLoad();

			FrameBuffer.ClearColor = Color.White;
			this.webTexture = new Texture2D(
				this.Width,
				this.Height,
				PixelInternalFormat.Rgba,
				PixelFormat.Rgba,
				PixelType.UnsignedByte);

			WebConfig config = new WebConfig()
			{

			};
			WebCore.Initialize(config, true);

			this.session = WebCore.CreateWebSession(new WebPreferences()
			{
				WebAudio = true,
				WebGL = true,
				AllowInsecureContent = true,
				WebSecurity = false,
				AppCache = false,
				CanScriptsOpenWindows = false,
				CanScriptsCloseWindows = false,
				CanScriptsAccessClipboard = true,
				Plugins = false,
			});

			this.view = WebCore.CreateWebView(this.webTexture.Width, this.webTexture.Height, this.session, WebViewType.Offscreen);
			this.view.IsTransparent = true; // Website background is transparent

			this.view.CreateSurface += (s, e) =>
			{
				// Create Awesomium default bitmap surface
				var bmpSurface = new BitmapSurface(e.Width, e.Height);
				bmpSurface.Updated += (s1, e1) =>
				{
					// If the surface changes, update the OpenGL texture
					this.webTexture.Load(bmpSurface.Buffer, bmpSurface.Width, bmpSurface.Height);
				};
				e.Surface = bmpSurface;
			};

			// Set injection events
			Input.Mouse.Move += Mouse_Move;
			Input.Mouse.ButtonDown += Mouse_ButtonDown;
			Input.Mouse.ButtonUp += Mouse_ButtonUp;
			Input.Mouse.WheelChanged += Mouse_WheelChanged;

			view.Source = new Uri("http://masterq32.de/");
		}

		void Mouse_ButtonDown(object sender, OpenTK.Input.MouseButtonEventArgs e)
		{
			switch (e.Button)
			{
				case OpenTK.Input.MouseButton.Left:
					view.InjectMouseDown(MouseButton.Left);
					break;
				case OpenTK.Input.MouseButton.Middle:
					view.InjectMouseDown(MouseButton.Middle);
					break;
				case OpenTK.Input.MouseButton.Right:
					view.InjectMouseDown(MouseButton.Right);
					break;
			}
		}

		void Mouse_ButtonUp(object sender, OpenTK.Input.MouseButtonEventArgs e)
		{
			switch (e.Button)
			{
				case OpenTK.Input.MouseButton.Left:
					view.InjectMouseUp(MouseButton.Left);
					break;
				case OpenTK.Input.MouseButton.Middle:
					view.InjectMouseUp(MouseButton.Middle);
					break;
				case OpenTK.Input.MouseButton.Right:
					view.InjectMouseUp(MouseButton.Right);
					break;
			}
		}

		void Mouse_WheelChanged(object sender, OpenTK.Input.MouseWheelEventArgs e)
		{
			if (Input.Keyboard[OpenTK.Input.Key.ShiftLeft])
				view.InjectMouseWheel(0, 20 * e.Delta);
			else
				view.InjectMouseWheel(20 * e.Delta, 0);
		}

		void Mouse_Move(object sender, OpenTK.Input.MouseMoveEventArgs e)
		{
			view.InjectMouseMove(e.X, e.Y);
		}

		protected override void OnUpdate(GameTime time)
		{
			// WebCore.Update must be called in OpenGL-Thread
			OpenGL.Invoke(WebCore.Update);
			base.OnUpdate(time);
		}

		protected override void OnDrawPreState(GameTime time)
		{
			// Clears the screen
			FrameBuffer.Clear();
		}

		protected override void OnDrawPostState(GameTime time)
		{
			// Draws the web interface over everything else
			this.Utilities.Draw(new Box2(0, 0, this.Width, this.Height), this.webTexture);
		}
	}
}

void function(...)
{
glGetErrror(); // Reset error
GL.function(...);
checkErrorAndThrowExceptionIfAny(glGetError());
}