public bool Load()
{
if (!_loaded)
{
_camera = Game.CurrentScene.PrimaryCamera.GetComponent <Camera>();
_program = new CubemapShaderProgram();
_cube = Geometry.CreateCube(_program, Vector3f.One * -_camera.Far / 2, Vector3f.One * _camera.Far / 2);
_textureID = GL.GenTexture();
GL.BindTexture(TextureTarget.TextureCubeMap, _textureID);
for (uint i = 0; i < _types.Length; i++)
{
try
{
_loadCubeSide(i);
}
catch (Exception)
{
return(false);
}
}
GL.BindTexture(TextureTarget.TextureCubeMap, 0);
ResourcesManager.AddDisposableResource(this);
_loaded = true;
}
return(true);
}
/// <summary>
/// Creates a buffer object of type T.
/// </summary>
/// <param name="Data">Specifies a pointer to data that will be copied into the data store for initialization.</param>
/// <param name="Target">Specifies the target buffer object.</param>
/// <param name="Hint">Specifies the expected usage of the data store.</param>
public VBO(T[] Data, BufferTarget Target = BufferTarget.ArrayBuffer, BufferUsageHint Hint = BufferUsageHint.StaticDraw)
{
ID = GL.CreateVBO <T>(BufferTarget = Target, Data, Hint);
Size = (Data is int[] ? 1 : (Data is Vector2f[] ? 2 : (Data is Vector3f[] ? 3 : (Data is Vector4f[] ? 4 : 0))));
PointerType = (Data is int[] ? VertexAttribPointerType.Int : VertexAttribPointerType.Float);
Count = Data.Length;
ResourcesManager.AddDisposableResource(this);
}
/// <summary>
/// Creates a buffer object of type T with a specified length.
/// This allows the array T[] to be larger than the actual size necessary to buffer.
/// Useful for reusing resources and avoiding unnecessary GC action.
/// </summary>
/// <param name="Data">An array of data of type T (which must be a struct) that will be buffered to the GPU.</param>
/// <param name="Position">An offset into the Data array from which to begin buffering.</param>
/// <param name="Length">The length of the valid data in the data array.</param>
/// <param name="Target">Specifies the target buffer object.</param>
/// <param name="Hint">Specifies the expected usage of the data store.</param>
public VBO(T[] Data, int Position, int Length, BufferTarget Target = BufferTarget.ArrayBuffer, BufferUsageHint Hint = BufferUsageHint.StaticDraw)
{
Length = MathHelper.Clamp(Length, 0, Data.Length);
ID = GL.CreateVBO <T>(BufferTarget = Target, Data, Hint, Position, Length);
this.Size = (Data is int[] ? 1 : (Data is Vector2f[] ? 2 : (Data is Vector3f[] ? 3 : (Data is Vector4f[] ? 4 : 0))));
this.PointerType = (Data is int[] ? VertexAttribPointerType.Int : VertexAttribPointerType.Float);
this.Count = Length;
ResourcesManager.AddDisposableResource(this);
}
private void _create(string vertexShader, string fragmentShader = null, string geometryShader = null, string tesscontrolShader = null, string tessevalShader = null)
{
_vertexSource = vertexShader;
_fragmentSource = fragmentShader;
_geometrySource = geometryShader;
_tessControlSource = tesscontrolShader;
_tessEvaluationSource = tessevalShader;
_compiled = false;
_uniformLocationsCache = new Dictionary <string, int>();
_valuesMap = new Dictionary <string, object>();
ResourcesManager.AddDisposableResource(this);
}
public Texture(string filename = null, TextureTarget target = TextureTarget.Texture2D, bool flipY = true)
{
_image = null;
TextureID = 0;
TextureTarget = target;
Filename = filename;
FlipY = flipY;
if (!string.IsNullOrEmpty(filename))
{
LoadImage(filename);
}
// Register this resource as a disposable resource
ResourcesManager.AddDisposableResource(this);
}
/// <summary>
/// Load and create a new image.
/// </summary>
/// <param name="file">The image file.</param>
/// <param name="offsetX">The X offset from which pixels will be read.</param>
/// <param name="offsetY">The Y offset from which pixels will be read.</param>
/// <param name="offsetZ">The Z offset from which pixels will be read.</param>
/// <param name="width">The width of the loaded.</param>
/// <param name="height">The height of the loaded.</param>
/// <param name="depth">The depth.</param>
/// <param name="format">The format in which pixels will be read.</param>
/// <param name="type">The type of data in which pixels will be read.</param>
public Image(string file, int offsetX = 0, int offsetY = 0, int offsetZ = 0, int width = 0, int height = 0, int depth = 1, DataFormat format = DataFormat.BGRA, DataType type = DataType.UnsignedByte)
{
ImageImporter importer = new ImageImporter();
_i = importer.LoadImage(file);
// Dispose the importer
importer.Dispose();
// Populate fields
_x = offsetX;
_y = offsetY;
_z = offsetZ;
_d = depth;
_f = format;
_t = type;
// Register this resource as a disposable resource
ResourcesManager.AddDisposableResource(this);
}
/// <summary>
/// Creates a framebuffer object and its associated resources (depth and frame buffers).
/// </summary>
/// <param name="size">Specifies the size (in pixels) of the framebuffer and its associated buffers.</param>
/// <param name="attachments">Specifies the attachments to use for the frame buffer.</param>
/// <param name="format">Specifies the internal pixel format for the frame buffer.</param>
/// <param name="mipmaps">Specifies whether to build mipmaps after the frame buffer is unbound.</param>
/// <param name="filterType">Specifies the type of filtering to apply to the frame buffer when bound as a texture.</param>
/// <param name="pixelType">Specifies the pixel type to use for the underlying format of the frame buffer.</param>
public FBO(Sizei size, FramebufferAttachment[] attachments, PixelInternalFormat format, bool mipmaps = false, TextureParameter filterType = TextureParameter.Linear, PixelType pixelType = PixelType.UnsignedByte, bool renderbuffer = true, bool multisampled = false)
{
Size = size;
Attachments = attachments;
Format = format;
MipMaps = mipmaps;
Multisampled = multisampled;
// First create the framebuffer
BufferID = GL.GenFramebuffer();
GL.BindFramebuffer(FramebufferTarget.Framebuffer, BufferID);
_attachementMap = new Dictionary <FramebufferAttachment, uint>();
TextureTarget textureTarget = Multisampled ? TextureTarget.Texture2DMultisample : TextureTarget.Texture2D;
if (Attachments.Length == 1 && Attachments[0] == FramebufferAttachment.DepthAttachment)
{
// if this is a depth attachment only
TextureID = new uint[] { GL.GenTexture() };
GL.BindTexture(textureTarget, TextureID[0]);
if (Multisampled)
{
GL.TexImage2DMultisample(textureTarget, GameSettings.MultisampleLevel, Format, Size.Width, Size.Height, true);
}
else
{
GL.TexImage2D(textureTarget, 0, Format, Size.Width, Size.Height, 0, PixelFormat.DepthComponent, PixelType.Float, IntPtr.Zero);
GL.TexParameteri(textureTarget, TextureParameterName.TextureMagFilter, TextureParameter.Nearest);
GL.TexParameteri(textureTarget, TextureParameterName.TextureMinFilter, TextureParameter.Nearest);
GL.TexParameteri(textureTarget, TextureParameterName.TextureWrapS, TextureParameter.ClampToEdge);
GL.TexParameteri(textureTarget, TextureParameterName.TextureWrapT, TextureParameter.ClampToEdge);
}
GL.BindTexture(textureTarget, 0);
GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, textureTarget, TextureID[0], 0);
GL.DrawBuffer(DrawBufferMode.None);
GL.ReadBuffer(ReadBufferMode.None);
_attachementMap.Add(FramebufferAttachment.DepthAttachment, 0);
}
else
{
// Create n texture buffers (known by the number of attachments)
TextureID = new uint[Attachments.Length];
GL.GenTextures(Attachments.Length, TextureID);
// Bind the n texture buffers to the framebuffer
for (int i = 0; i < Attachments.Length; i++)
{
GL.BindTexture(textureTarget, TextureID[i]);
if (Multisampled)
{
GL.TexImage2DMultisample(textureTarget, GameSettings.MultisampleLevel, Format, Size.Width, Size.Height, true);
}
else
{
GL.TexImage2D(textureTarget, 0, Format, Size.Width, Size.Height, 0, PixelFormat.Rgba, pixelType, IntPtr.Zero);
if (MipMaps)
{
GL.TexParameteri(textureTarget, TextureParameterName.TextureMagFilter, TextureParameter.Linear);
GL.TexParameteri(textureTarget, TextureParameterName.TextureMinFilter, TextureParameter.LinearMipMapLinear);
GL.GenerateMipmap(Multisampled ? GenerateMipmapTarget.Texture2DMultisample : GenerateMipmapTarget.Texture2D);
}
else
{
GL.TexParameteri(textureTarget, TextureParameterName.TextureMagFilter, filterType);
GL.TexParameteri(textureTarget, TextureParameterName.TextureMinFilter, filterType);
}
}
GL.BindTexture(textureTarget, 0);
GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, Attachments[i], textureTarget, TextureID[i], 0);
_attachementMap.Add(Attachments[i], TextureID[i]);
}
if (renderbuffer)
{
// Create and attach a 24-bit depth buffer to the framebuffer
DepthID = GL.GenRenderbuffer();
GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, DepthID);
if (Multisampled)
{
GL.RenderbufferStorageMultisample(RenderbufferTarget.Renderbuffer, GameSettings.MultisampleLevel, PixelInternalFormat.Depth32fStencil8, Size.Width, Size.Height);
}
else
{
GL.RenderbufferStorage(RenderbufferTarget.Renderbuffer, PixelInternalFormat.Depth24Stencil8, Size.Width, Size.Height);
}
GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, 0);
GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthStencilAttachment, RenderbufferTarget.Renderbuffer, DepthID);
//GL.TexParameteri(textureTarget, TextureParameterName.TextureMagFilter, TextureParameter.Nearest);
//GL.TexParameteri(textureTarget, TextureParameterName.TextureMinFilter, TextureParameter.Nearest);
//GL.TexParameteri(textureTarget, TextureParameterName.TextureWrapS, TextureParameter.ClampToEdge);
//GL.TexParameteri(textureTarget, TextureParameterName.TextureWrapT, TextureParameter.ClampToEdge);
//GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, textureTarget, DepthID, 0);
//GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.StencilAttachment, textureTarget, DepthID, 0);
_attachementMap.Add(FramebufferAttachment.DepthStencilAttachment, DepthID);
//_attachementMap.Add(FramebufferAttachment.StencilAttachment, DepthID);
}
}
// Build the framebuffer and check for errors
FramebufferStatus status = GL.CheckFramebufferStatus(FramebufferTarget.Framebuffer);
if (status != FramebufferStatus.FramebufferComplete)
{
Console.WriteLine("Frame buffer did not compile correctly. Returned {0}, glError: {1}", status.ToString(), GL.GetError().ToString());
}
// Make sure this framebuffer is not modified from outside
GL.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
// Register this framebuffer as a disposable object
ResourcesManager.AddDisposableResource(this);
}
/// \internal
/// <summary>Creates the audio context using the specified device.</summary>
/// <param name="device">The device descriptor obtained through AudioContext.AvailableDevices, or null for the default device.</param>
/// <param name="freq">Frequency for mixing output buffer, in units of Hz. Pass 0 for driver default.</param>
/// <param name="refresh">Refresh intervals, in units of Hz. Pass 0 for driver default.</param>
/// <param name="sync">Flag, indicating a synchronous context.</param>
/// <param name="enableEfx">Indicates whether the EFX extension should be initialized, if present.</param>
/// <param name="efxAuxiliarySends">Requires EFX enabled. The number of desired Auxiliary Sends per source.</param>
/// <exception cref="ArgumentOutOfRangeException">Occurs when a specified parameter is invalid.</exception>
/// <exception cref="AudioDeviceException">
/// Occurs when the specified device is not available, or is in use by another program.
/// </exception>
/// <exception cref="AudioContextException">
/// Occurs when an audio context could not be created with the specified parameters.
/// </exception>
/// <exception cref="NotSupportedException">
/// Occurs when an AudioContext already exists.</exception>
/// <remarks>
/// <para>For maximum compatibility, you are strongly recommended to use the default constructor.</para>
/// <para>Multiple AudioContexts are not supported at this point.</para>
/// <para>
/// The number of auxilliary EFX sends depends on the audio hardware and drivers. Most Realtek devices, as well
/// as the Creative SB Live!, support 1 auxilliary send. Creative's Audigy and X-Fi series support 4 sends.
/// Values higher than supported will be clamped by the driver.
/// </para>
/// </remarks>
void CreateContext(string device, int freq, int refresh, bool sync, bool enableEfx, MaxAuxiliarySends efxAuxiliarySends)
{
if (!AudioDeviceEnumerator.IsOpenALSupported)
{
throw new DllNotFoundException(AL.Lib);
}
if (AudioDeviceEnumerator.Version == AudioDeviceEnumerator.AlcVersion.Alc1_1 && AudioDeviceEnumerator.AvailablePlaybackDevices.Count == 0) // Alc 1.0 does not support device enumeration.
{
throw new NotSupportedException("No audio hardware is available.");
}
if (context_exists)
{
throw new NotSupportedException("Multiple AudioContexts are not supported.");
}
if (freq < 0)
{
throw new ArgumentOutOfRangeException("freq", freq, "Should be greater than zero.");
}
if (refresh < 0)
{
throw new ArgumentOutOfRangeException("refresh", refresh, "Should be greater than zero.");
}
if (!String.IsNullOrEmpty(device))
{
device_name = device;
device_handle = Alc.OpenDevice(device); // try to open device by name
}
if (device_handle == IntPtr.Zero)
{
device_name = "IntPtr.Zero (null string)";
device_handle = Alc.OpenDevice(null); // try to open unnamed default device
}
if (device_handle == IntPtr.Zero)
{
device_name = AudioContext.DefaultDevice;
device_handle = Alc.OpenDevice(AudioContext.DefaultDevice); // try to open named default device
}
if (device_handle == IntPtr.Zero)
{
device_name = "None";
throw new AudioDeviceException(String.Format("Audio device '{0}' does not exist or is tied up by another application.",
String.IsNullOrEmpty(device) ? "default" : device));
}
CheckErrors();
// Build the attribute list
List <int> attributes = new List <int>();
if (freq != 0)
{
attributes.Add((int)AlcContextAttributes.Frequency);
attributes.Add(freq);
}
if (refresh != 0)
{
attributes.Add((int)AlcContextAttributes.Refresh);
attributes.Add(refresh);
}
attributes.Add((int)AlcContextAttributes.Sync);
attributes.Add(sync ? 1 : 0);
if (enableEfx && Alc.IsExtensionPresent(device_handle, "ALC_EXT_EFX"))
{
int num_slots;
switch (efxAuxiliarySends)
{
case MaxAuxiliarySends.One:
case MaxAuxiliarySends.Two:
case MaxAuxiliarySends.Three:
case MaxAuxiliarySends.Four:
num_slots = (int)efxAuxiliarySends;
break;
default:
case MaxAuxiliarySends.UseDriverDefault:
Alc.GetInteger(device_handle, AlcGetInteger.EfxMaxAuxiliarySends, 1, out num_slots);
break;
}
attributes.Add((int)AlcContextAttributes.EfxMaxAuxiliarySends);
attributes.Add(num_slots);
}
attributes.Add(0);
context_handle = Alc.CreateContext(device_handle, attributes.ToArray());
if (context_handle == ContextHandle.Zero)
{
Alc.CloseDevice(device_handle);
throw new AudioContextException("The audio context could not be created with the specified parameters.");
}
CheckErrors();
// HACK: OpenAL SI on Linux/ALSA crashes on MakeCurrent. This hack avoids calling MakeCurrent when
// an old OpenAL version is detect - it may affect outdated OpenAL versions different than OpenAL SI,
// but it looks like a good compromise for now.
if (AudioDeviceEnumerator.AvailablePlaybackDevices.Count > 0)
{
MakeCurrent();
}
CheckErrors();
device_name = Alc.GetString(device_handle, AlcGetString.DeviceSpecifier);
lock (audio_context_lock)
{
available_contexts.Add(this.context_handle, this);
context_exists = true;
}
// Register this resource as a disposable resource.
ResourcesManager.AddDisposableResource(this);
}
