public GL(IntPtr windowHandle)
{
if (GetCurrent(false) != null)
{
throw new GLException("GLContext already exists in current thread. Try launching in different thread");
}
if (windowHandle == IntPtr.Zero)
{
throw new ArgumentException("windowHandle");
}
lock (_locker) {
NativeMethods.LoadDLLs();
_deviceContextPtr = NativeMethods.GetDeviceContext(windowHandle);
Assert.False(_deviceContextPtr == IntPtr.Zero);
var pixelFormatDescriptor = PixelFormatDescriptor.CreateDefault();
var pixelformat = NativeMethods.ChoosePixelFormat(_deviceContextPtr, ref pixelFormatDescriptor);
Assert.False(pixelformat == 0);
var success = NativeMethods.SetPixelFormat(_deviceContextPtr, pixelformat, ref pixelFormatDescriptor);
Assert.True(success);
_renderingContextPtr = NativeMethods.CreateContext(_deviceContextPtr);
if (MakeCurrent() == false)
{
MakeCurrentEmpty();
NativeMethods.DeleteContext(_renderingContextPtr);
var error = "Error making created context current.";
Log.Error(error);
throw new GLException(error);
}
LoadExtensions();
LoadConstants();
Log.Info(string.Format("Initialized GL context version: {0}.", Version));
if (Version < new GLVersion(4, 0))
{
Dispose();
var error = string.Format("Only OpenGL 4.0 and higher versions supported. You have {0}", Version);
Log.Error(error);
throw new GLException(error);
}
SetupDebugCallback();
_currentContext.Value = this;
_textures = new uint[MaxTextureUnits];
ActiveTexture(TextureUnit.Texture0);
CheckForError();
}
}
public static RenderingContext FromBitmapInfo(
BitmapInfo bitmapInfo,
PixelFormatDescriptor pfd,
out IntPtr bitmapHandle)
{
IntPtr dc = WGL.GetDC(IntPtr.Zero);
IntPtr compatibleDc = WGL.CreateCompatibleDC(dc);
WGL.ReleaseDC(IntPtr.Zero, dc);
IntPtr ppvBits;
bitmapHandle = WGL.CreateDIBSection(compatibleDc, ref bitmapInfo, DIBDataType.RgbColors, out ppvBits, IntPtr.Zero, 0U);
if (bitmapHandle == IntPtr.Zero)
{
throw new InternalException("Error in CreateDIBSection", (Exception) new Win32Exception(Marshal.GetLastWin32Error()));
}
if (WGL.SelectObject(compatibleDc, bitmapHandle) == IntPtr.Zero)
{
throw new InternalException("SelectObject failed");
}
int pixelFormatIndex = RenderingContext.smethod_0(compatibleDc, pfd);
IntPtr context = WGL.wglCreateContext(compatibleDc);
if (context == IntPtr.Zero)
{
throw new InternalException("Error in wglCreateContext", (Exception) new Win32Exception(Marshal.GetLastWin32Error()));
}
return(new RenderingContext(IntPtr.Zero, compatibleDc, true, context, pixelFormatIndex));
}
// Note: there is no relevant ARB function.
internal static GraphicsMode SetGraphicsModePFD(WinGraphicsMode mode_selector,
GraphicsMode mode, WinWindowInfo window)
{
Debug.Write("Setting pixel format... ");
if (window == null)
{
throw new ArgumentNullException("window", "Must point to a valid window.");
}
if (!mode.Index.HasValue)
{
mode = mode_selector.SelectGraphicsMode(
mode.ColorFormat, mode.Depth, mode.Stencil,
mode.Samples, mode.AccumulatorFormat,
mode.Buffers, mode.Stereo);
}
PixelFormatDescriptor pfd = new PixelFormatDescriptor();
Functions.DescribePixelFormat(
window.DeviceContext, (int)mode.Index.Value,
API.PixelFormatDescriptorSize, ref pfd);
Debug.WriteLine(mode.Index.ToString());
if (!Functions.SetPixelFormat(window.DeviceContext, (int)mode.Index.Value, ref pfd))
{
throw new GraphicsContextException(String.Format(
"Requested GraphicsMode not available. SetPixelFormat error: {0}",
Marshal.GetLastWin32Error()));
}
return(mode);
}
public PixelFormat(DeviceContext dc, ref PixelFormatDescriptor pfd)
{
m_Index = 0;
m_Descriptor = pfd;
m_Descriptor.Size = PixelFormatDescriptor.StructSize;
m_Descriptor.Version = 1;
m_Index = IGE.Platform.Win32.API.Externals.ChoosePixelFormat(dc.Handle, ref m_Descriptor);
}
public static IntPtr CreateContext(ref IntPtr windowHandle, FramebufferFormat framebufferFormat, int major, int minor, OpenGLContextFlags flags, bool directRendering, IntPtr shareContext)
{
EnsureInit();
bool hasTempWindow = windowHandle == IntPtr.Zero;
if (hasTempWindow)
{
windowHandle = Win32Helper.CreateNativeWindow(WindowStylesEx.WS_EX_OVERLAPPEDWINDOW,
WindowStyles.WS_CLIPSIBLINGS | WindowStyles.WS_CLIPCHILDREN,
"SPB intermediary context",
0, 0, 1, 1);
}
IntPtr dcHandle = GetDC(windowHandle);
int pixelFormat = FindPerfectFormat(dcHandle, framebufferFormat);
// Perfect match not availaible, search for the closest
if (pixelFormat == -1)
{
pixelFormat = FindClosestFormat(dcHandle, framebufferFormat);
}
if (pixelFormat == -1)
{
throw new PlatformException("Cannot find a valid pixel format");
}
PixelFormatDescriptor pfd = PixelFormatDescriptor.Create();
int res = DescribePixelFormat(dcHandle, pixelFormat, Marshal.SizeOf <PixelFormatDescriptor>(), ref pfd);
if (res == 0)
{
throw new PlatformException($"DescribePixelFormat failed: {Marshal.GetLastWin32Error()}");
}
res = SetPixelFormat(dcHandle, pixelFormat, ref pfd);
if (res == 0)
{
throw new PlatformException($"DescribePixelFormat failed: {Marshal.GetLastWin32Error()}");
}
List <int> contextAttributes = GetContextCreationARBAttribute(major, minor, flags);
IntPtr context = CreateContextAttribsArb(dcHandle, shareContext, contextAttributes.ToArray());
ReleaseDC(windowHandle, dcHandle);
if (hasTempWindow)
{
DestroyWindow(windowHandle);
}
return(context);
}
public PixelFormat(DeviceContext dc, int index)
{
m_Index = 0;
m_Descriptor = new PixelFormatDescriptor();
if (dc.Disposed || 0 == IGE.Platform.Win32.API.Externals.DescribePixelFormat(dc.Handle, index, PixelFormatDescriptor.StructSize, ref m_Descriptor))
{
return;
}
m_hDC = dc.Handle;
m_Index = index;
}
private void Form1_Load(object sender, EventArgs e)
{
Graphics g = this.CreateGraphics();
hdc = g.GetHdc();
PixelFormatDescriptor m_pfd = new PixelFormatDescriptor();
m_pfd.Flags = (uint)(WGL.PFD_FLAGS.DOUBLEBUFFER | WGL.PFD_FLAGS.DRAW_TO_WINDOW | WGL.PFD_FLAGS.SUPPORT_OPENGL | WGL.PFD_FLAGS.TYPE_RGBA);
m_pfd.PixelType = 0;
m_pfd.ColorBits = 24;
m_pfd.DepthBits = 32;
m_pfd.LayerType = 0;
Int32 pf = m_wgl.ChoosePixelFormat(hdc, m_pfd);
if (pf == 0)
{
throw new Exception("ChoosePixelFormat failed");
}
Int32 spf = m_wgl.SetPixelFormat(hdc, pf, m_pfd);
if (spf != 1)
{
throw new Exception("SetPixelFormat failed");
}
IntPtr ctx = m_wgl.CreateContext(hdc);
m_wgl.MakeCurrent(hdc, ctx);
m_gl.MatrixMode(GL.GL_FLAGS.PROJECTION);
m_gl.Frustum(-0.5F, 0.5F, -0.5F, 0.5F, 1.0F, 3.0F);
m_gl.MatrixMode(GL.GL_FLAGS.MODELVIEW);
m_gl.Translatef(0.0F, 0.0F, -2.0F);
m_gl.Rotatef(30.0F, 1.0F, 0.0F, 0.0F);
m_gl.Rotatef(30.0F, 0.0F, 1.0F, 0.0F);
m_gl.Enable(GL.GL_FLAGS.DEPTH_TEST);
m_gl.Enable(GL.GL_FLAGS.COLOR_MATERIAL);
m_gl.Enable(GL.GL_FLAGS.LIGHTING);
m_gl.Enable(GL.GL_FLAGS.LIGHT0);
m_gl.ColorMaterial(GL.GL_FLAGS.FRONT_AND_BACK, GL.GL_FLAGS.AMBIENT_AND_DIFFUSE);
this.Invalidate();
}
private static int smethod_0(IntPtr hdc, PixelFormatDescriptor pfd)
{
int iPixelFormat = WGL.ChoosePixelFormat(hdc, ref pfd);
if (iPixelFormat == 0)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
if (WGL.SetPixelFormat(hdc, iPixelFormat, ref pfd) == 0)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
return(iPixelFormat);
}
public static RenderingContext FromWindowHandle(
IntPtr windowHandle,
PixelFormatDescriptor pfd)
{
IntPtr dc = WGL.GetDC(windowHandle);
WGL.wglSwapBuffers(dc);
int pixelFormatIndex = RenderingContext.smethod_0(dc, pfd);
IntPtr context = WGL.wglCreateContext(dc);
if (context == IntPtr.Zero)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
return(new RenderingContext(windowHandle, dc, false, context, pixelFormatIndex));
}
public static int CreateWindow(string title)
{
// Window class
WindowClassEx windowClass = new WindowClassEx
{
Size = (uint)Marshal.SizeOf <WindowClassEx>(),
WindowProc = _wndProc,
InstanceHandle = GetModuleHandle(null),
CursorHandle = LoadCursor(IntPtr.Zero, new IntPtr(IDC_ARROW)),
ClassName = ClassName
};
RegisterClassEx(ref windowClass);
// Window
Rectangle rect = new Rectangle {
Left = 0, Top = 0, Right = _width, Bottom = _height
};
AdjustWindowRect(ref rect, WS_OVERLAPPEDWINDOW, false);
_hWnd = CreateWindowEx(0, ClassName, title, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, rect.Right - rect.Left, rect.Bottom - rect.Top,
IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
// GL Context
PixelFormatDescriptor pfd = new PixelFormatDescriptor
{
Size = (short)Marshal.SizeOf <PixelFormatDescriptor>(),
Version = 1,
Flags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PixelType = PFD_TYPE_RGBA,
ColorBits = 24,
StencilBits = 8
};
_hDC = GetDC(_hWnd);
int pixelFormat = ChoosePixelFormat(_hDC, ref pfd);
SetPixelFormat(_hDC, pixelFormat, ref pfd);
IntPtr hRC = wglCreateContext(_hDC);
wglMakeCurrent(_hDC, hRC);
return(0);
}
private static AccelerationType GetAccelerationType(ref PixelFormatDescriptor pfd)
{
AccelerationType type = AccelerationType.ICD;
if ((pfd.Flags & PixelFormatDescriptorFlags.GENERIC_FORMAT) != 0)
{
if ((pfd.Flags & PixelFormatDescriptorFlags.GENERIC_ACCELERATED) != 0)
{
type = AccelerationType.MCD;
}
else
{
type = AccelerationType.None;
}
}
return(type);
}
public GLTexture Read()
{
int size = _header.ImageWidth * _header.ImageHeight * _header.BytesPerPixel;
PixelFormatDescriptor format = GetColorFormat();
if (format != null)
{
return(ReadTexture(_input, format));
}
using (SafeHGlobalHandle pixels = _input.ReadBuff(size))
{
TexPixelFormatsConverter converter = new TexPixelFormatsConverter(_header, pixels, PixelFormats.Bgra32);
using (SafeHGlobalHandle newPixels = converter.Convert())
using (UnmanagedMemoryStream input = newPixels.OpenStream(FileAccess.Read))
return(ReadTexture(input, PixelFormat.Format32bppArgb));
}
}
private static GraphicsMode DescribePixelFormatPFD(IntPtr device, ref PixelFormatDescriptor pfd,
int pixelformat)
{
GraphicsMode created_mode = null;
if (Functions.DescribePixelFormat(device, pixelformat, pfd.Size, ref pfd) > 0)
{
created_mode = new GraphicsMode(
new IntPtr(pixelformat),
new ColorFormat(pfd.RedBits, pfd.GreenBits, pfd.BlueBits, pfd.AlphaBits),
pfd.DepthBits,
pfd.StencilBits,
0, // MSAA not supported when using PixelFormatDescriptor
new ColorFormat(pfd.AccumRedBits, pfd.AccumGreenBits, pfd.AccumBlueBits, pfd.AccumAlphaBits),
(pfd.Flags & PixelFormatDescriptorFlags.DOUBLEBUFFER) != 0 ? 2 : 1,
(pfd.Flags & PixelFormatDescriptorFlags.STEREO) != 0);
}
return(created_mode);
}
public static RenderingContext FromWindowHandle(
IntPtr windowHandle,
int pixelFormatIndex)
{
IntPtr dc = WGL.GetDC(windowHandle);
WGL.wglSwapBuffers(dc);
PixelFormatDescriptor empty = PixelFormatDescriptor.Empty;
if (WGL.SetPixelFormat(dc, pixelFormatIndex, ref empty) == 0)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
IntPtr context = WGL.wglCreateContext(dc);
if (context == IntPtr.Zero)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
return(new RenderingContext(windowHandle, dc, false, context, pixelFormatIndex));
}
public WglContext(WglContext sharedWith, GlVersion version, IntPtr context, IntPtr hWnd, IntPtr dc, int pixelFormat,
PixelFormatDescriptor formatDescriptor)
{
Version = version;
_sharedWith = sharedWith;
_context = context;
_hWnd = hWnd;
_dc = dc;
_pixelFormat = pixelFormat;
_formatDescriptor = formatDescriptor;
StencilSize = formatDescriptor.StencilBits;
using (MakeCurrent())
GlInterface = new GlInterface(version, proc =>
{
var ext = wglGetProcAddress(proc);
if (ext != IntPtr.Zero)
{
return(ext);
}
return(GetProcAddress(WglDisplay.OpenGl32Handle, proc));
});
}
private void Form1_Load(object sender, EventArgs e)
{
Graphics g = this.CreateGraphics();
hdc = g.GetHdc();
PixelFormatDescriptor m_pfd = new PixelFormatDescriptor();
m_pfd.Flags = (uint)(WGL.PFD_FLAGS.DOUBLEBUFFER | WGL.PFD_FLAGS.DRAW_TO_WINDOW | WGL.PFD_FLAGS.SUPPORT_OPENGL | WGL.PFD_FLAGS.TYPE_RGBA);
m_pfd.PixelType = 0;
m_pfd.ColorBits = 24;
m_pfd.DepthBits = 32;
m_pfd.LayerType = 0;
Int32 pf = m_wgl.ChoosePixelFormat(hdc, m_pfd);
if (pf == 0) throw new Exception("ChoosePixelFormat failed");
Int32 spf = m_wgl.SetPixelFormat(hdc, pf, m_pfd);
if (spf != 1) throw new Exception("SetPixelFormat failed");
IntPtr ctx = m_wgl.CreateContext(hdc);
m_wgl.MakeCurrent(hdc, ctx);
m_gl.MatrixMode(GL.GL_FLAGS.PROJECTION);
m_gl.Frustum(-0.5F, 0.5F, -0.5F, 0.5F, 1.0F, 3.0F);
m_gl.MatrixMode(GL.GL_FLAGS.MODELVIEW);
m_gl.Translatef(0.0F, 0.0F, -2.0F);
m_gl.Rotatef(30.0F, 1.0F, 0.0F, 0.0F);
m_gl.Rotatef(30.0F, 0.0F, 1.0F, 0.0F);
m_gl.Enable(GL.GL_FLAGS.DEPTH_TEST);
m_gl.Enable(GL.GL_FLAGS.COLOR_MATERIAL);
m_gl.Enable(GL.GL_FLAGS.LIGHTING);
m_gl.Enable(GL.GL_FLAGS.LIGHT0);
m_gl.ColorMaterial(GL.GL_FLAGS.FRONT_AND_BACK, GL.GL_FLAGS.AMBIENT_AND_DIFFUSE);
this.Invalidate();
}
internal static extern bool SetPixelFormat(IntPtr deviceContext, uint pixelFormat, [In] ref PixelFormatDescriptor ppfd);
public static extern int DescribePixelFormat(IntPtr hdc, int ipfd, uint cjpfd, ref PixelFormatDescriptor ppfd);
internal static extern bool SetPixelFormat(IntPtr deviceContextHandle, int pixelFormatIndex, ref PixelFormatDescriptor pixelFormatDescriptor);
internal static extern int ChoosePixelFormat(IntPtr deviceContextHandle, ref PixelFormatDescriptor pixelFormatDescriptor);
public extern static unsafe int wglChoosePixelFormat(IntPtr hdc, ref PixelFormatDescriptor ppfd);
public static extern int SetPixelFormat(IntPtr hdc, int iPixelFormat, ref PixelFormatDescriptor ppfd);
private static extern bool SetPixelFormat(IntPtr hdc, int format, ref PixelFormatDescriptor ppfd);
private void Init()
{
var pfd = new PixelFormatDescriptor();
pfd.Initialize();
this.InitializePixelFormatDescriptor( ref pfd );
this.hDC = WindowsOpenGLNative.GetDC( this.Handle );
if (this.hDC == IntPtr.Zero)
throw new Win32Exception( Marshal.GetLastWin32Error() );
var iPixelformat = WindowsOpenGLNative.ChoosePixelFormat( this.hDC, ref pfd );
if (iPixelformat == 0)
throw new Win32Exception( Marshal.GetLastWin32Error() );
// Set the pixel format
if (!WindowsOpenGLNative.SetPixelFormat( this.hDC, iPixelformat, ref pfd ))
throw new Win32Exception( Marshal.GetLastWin32Error() );
// Create a new OpenGL rendering context
this.hRC = WindowsOpenGLNative.wglCreateContext( this.hDC );
if (this.hRC == IntPtr.Zero)
throw new Win32Exception( Marshal.GetLastWin32Error() );
}
internal static extern uint ChoosePixelFormat(IntPtr deviceContext, [In] ref PixelFormatDescriptor ppfd);
protected virtual void InitializePixelFormatDescriptor( ref PixelFormatDescriptor pfd )
{
}
// Something for the contexts
private bool setPixelFormat(IntPtr pmdevice, int pixelFormat, ref PixelFormatDescriptor pfd)
{
LoadLibrary("opengl32.dll");
return _SetPixelFormat(pmdevice, pixelFormat, ref pfd);
}
private static extern int ChoosePixelFormat(IntPtr hdc, [In] ref PixelFormatDescriptor ppfd);
public static extern int ChoosePixelFormat(IntPtr deviceContext, ref PixelFormatDescriptor pixelFormatDescriptor);
public static extern bool SetPixelFormat(IntPtr dc, int format, ref PixelFormatDescriptor pfd);
public static extern bool SetPixelFormat(IntPtr deviceContext, int pixelFormat, ref PixelFormatDescriptor pixelFormatDescriptor);
public static extern int ChoosePixelFormat(IntPtr hdc, ref PixelFormatDescriptor ppfd);
private static extern bool _SetPixelFormat(IntPtr pmdevice, int pixelFormat, ref PixelFormatDescriptor pfd);
internal static extern int ChoosePixelFormat(IntPtr deviceContextHandle, ref PixelFormatDescriptor pixelFormatDescriptor);
public OpenGLWindow(INativeWindow parent, int x, int y, int width, int height) : base(new WindowCreateStruct {
WindowTitle = GameConfig.GameWindowTitle, //"IGE OpenGLWindow",
X = x,
Y = y,
Width = width,
Height = height,
Style = GameConfig.FullScreen ? WindowStyleFlags.Popup : Win32NativeWindow.DefaultStyle,
ExStyle = ExtendedWindowStyleFlags.ApplicationWindow,
ParentWindow = (Win32NativeWindow)parent,
Menu = IntPtr.Zero,
Param = IntPtr.Zero,
ClassName = "IGEOpenGLWindow",
ClassStyle = WindowClassStyle.HREDRAW | WindowClassStyle.VREDRAW | WindowClassStyle.OWNDC,
Background = (IntPtr)0, // no background brush is needed since opengl has its own renderer
Icon = (GameConfig.IconResourceId != 0) ? IGE.Platform.Win32.API.Externals.LoadIcon(Win32Application.GetInstanceHandle(), (IntPtr)GameConfig.IconResourceId) : IGE.Platform.Win32.API.Externals.LoadIcon(IntPtr.Zero, (IntPtr) 32512), // 32512 = IDI_APPLICATION
Cursor = IGE.Platform.Win32.API.Externals.LoadCursor(IntPtr.Zero, (IntPtr) 32512), // 32512 = IDC_ARROW
ClassMenu = IntPtr.Zero,
ClassExtra = 0,
WindowExtra = 0
})
{
m_DeviceContext = null;
if (!Exists)
{
return;
}
m_DeviceContext = new DeviceContext(this);
if (m_DeviceContext.Disposed)
{
GameDebugger.EngineLog(LogLevel.Error, "Failed to properly create a device context");
throw new UserFriendlyException("Failed to properly create a device context", "Graphics initialization error");
}
/*
* // This enumerates all pixel formats, supported by the device context to the log file
* for( int i = PixelFormat.GetCount(m_DeviceContext); i > 0; i-- ) {
* PixelFormat dpf = new PixelFormat(m_DeviceContext, i);
* GameDebugger.Log(dpf);
* }
*/
// change pixelformat for the window's device context
// | PixelFormatDescriptorFlags.SWAP_EXCHANGE
PixelFormatDescriptor pfd = new PixelFormatDescriptor {
Flags = PixelFormatDescriptorFlags.DOUBLEBUFFER | PixelFormatDescriptorFlags.SUPPORT_OPENGL | PixelFormatDescriptorFlags.DRAW_TO_WINDOW,
PixelType = ApiPixelType.RGBA,
ColorBits = (byte)GameConfig.ColorBits,
RedBits = 8, GreenBits = 8, BlueBits = 8, AlphaBits = 8,
RedShift = 0, GreenShift = 0, BlueShift = 0, AlphaShift = 0,
DepthBits = (byte)GameConfig.DepthBufferBits,
StencilBits = (byte)GameConfig.StencilBufferBits,
AccumBits = (byte)GameConfig.AccumBufferBits, AccumRedBits = 0, AccumGreenBits = 0, AccumBlueBits = 0, AccumAlphaBits = 0,
AuxBuffers = 0, LayerType = 0, LayerMask = 0, VisibleMask = 0, DamageMask = 0
};
PixelFormat pf = new PixelFormat(m_DeviceContext, ref pfd);
GameDebugger.EngineLog(LogLevel.Debug, "{0}", pf);
if (!pf.Exists)
{
throw new Exception("Could not find a suitable pixel format for an OpenGL window.");
}
bool res = pf.Apply();
//GameDebugger.Log("Chosen: {0} {1}", pf.Exists, pf.ToString());
//GameDebugger.Log("Apply result: {0}", res);
if (!res)
{
GameDebugger.EngineLog(LogLevel.Debug, "Failed applying requested pixel format, trying to apply by a found index");
PixelFormat pf2 = new PixelFormat(m_DeviceContext, pf.Index);
GameDebugger.EngineLog(LogLevel.Debug, "{0}", pf2);
res = pf2.Apply();
//GameDebugger.Log("Real: {0} {1}", pf2.Exists, pf2.ToString());
//GameDebugger.Log("Apply result: {0}", res);
if (!res)
{
throw new Exception(String.Format("Error trying to set {0}", pf2.ToString()));
}
}
m_ResourceContext = new ResourceContext(m_DeviceContext);
if (m_ResourceContext.Disposed)
{
int pixelFormats = PixelFormat.GetCount(m_DeviceContext);
GameDebugger.EngineLog(LogLevel.Debug, "Supported pixel formats:");
for (int i = 0; i < pixelFormats; i++)
{
pf = new PixelFormat(m_DeviceContext, i);
GameDebugger.EngineLog(LogLevel.Debug, "{0}", pf);
}
throw new Exception("Could not create a resource context for the OpenGLWindow");
}
m_ResourceContext.Activate();
// "reload" because we want context specific extension functions to be loaded as well
WGL.RuntimeImport();
GL.RuntimeImport();
Application.IdleEvent += OnIdle;
}
public async override Task <GLTexture> ReadTextureAsync(CancellationToken cancelationToken)
{
if (cancelationToken.IsCancellationRequested)
{
return(RaiseTextureReaded(null));
}
using (SafeHGlobalHandle pixels = new SafeHGlobalHandle(_map.Width * _map.Height * 3))
{
using (Stream stream = pixels.OpenStream(FileAccess.ReadWrite))
{
if (cancelationToken.IsCancellationRequested)
{
return(RaiseTextureReaded(null));
}
CreateBackground(stream);
foreach (MimTile tile in _map.LayredTiles[0])
{
if (cancelationToken.IsCancellationRequested)
{
return(RaiseTextureReaded(null));
}
//if (tile.Layered.Z < _map.LayredTiles[0][0].Layered.Z)
// break;
int position = tile.Layered.GetPositionInImage(_map, _map.Width * 3);
stream.Seek(position, SeekOrigin.Begin);
Color[] colors = ReadTileColors(tile);
for (int i = 0; i < 16; i++)
{
for (int k = 0; k < 16; k++)
{
WriteColor(colors[i * 16 + k], tile.Layered.BlendType, stream);
}
if (i < 15)
{
stream.Seek((_map.Width - 16) * 3, SeekOrigin.Current);
}
}
}
}
if (cancelationToken.IsCancellationRequested)
{
return(RaiseTextureReaded(null));
}
PixelFormatDescriptor pixelFormat = System.Drawing.Imaging.PixelFormat.Format24bppRgb;
int textureId;
using (GLService.AcquireContext())
{
GL.GenTextures(1, out textureId);
GL.BindTexture(TextureTarget.Texture2D, textureId);
GL.TexImage2D(TextureTarget.Texture2D, 0, pixelFormat, _map.Width, _map.Height, 0, pixelFormat, pixelFormat, pixels.DangerousGetHandle());
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
}
if (cancelationToken.IsCancellationRequested)
{
return(RaiseTextureReaded(null));
}
return(new GLTexture(textureId, _map.Width, _map.Height, pixelFormat));
}
}
public static extern int ChoosePixelFormat(IntPtr hDc, ref PixelFormatDescriptor pfd);
internal static extern bool SetPixelFormat(IntPtr deviceContextHandle, int pixelFormatIndex, ref PixelFormatDescriptor pixelFormatDescriptor);
public static extern int DescribePixelFormat(IntPtr hdc, int ipfd, uint cjpfd, ref PixelFormatDescriptor pfd);
// Initializes the contexts
public void initContexts()
{
bContextsInitiated= true;
windowHandle= Handle;
if(windowHandle== IntPtr.Zero)
{
MessageBox.Show("Window creation error. No window handle.", "Fatal Error", MessageBoxButtons.OK, MessageBoxIcon.Hand);
Environment.Exit(-1);
}
// Variables
PixelFormatDescriptor pfd= new PixelFormatDescriptor();
int pixelFormat;
pfd.nSize= (short)Marshal.SizeOf(pfd);
pfd.nVersion= 1;
pfd.dwFlags= 0x25;
pfd.iPixelType= 0;
pfd.cColorBits= colorBits;
pfd.cRedBits= 0;
pfd.cRedShift= 0;
pfd.cGreenBits= 0;
pfd.cGreenShift= 0;
pfd.cBlueBits= 0;
pfd.cBlueShift= 0;
pfd.cAlphaBits= 0;
pfd.cAlphaShift= 0;
pfd.cAccumBits= accumBits;
pfd.cAccumRedBits= 0;
pfd.cAccumGreenBits= 0;
pfd.cAccumBlueBits= 0;
pfd.cAccumAlphaBits= 0;
pfd.cDepthBits= depthBits;
pfd.cStencilBits= stencilBits;
pfd.cAuxBuffers= 0;
pfd.iLayerType= 0;
pfd.bReserved= 0;
pfd.dwLayerMask= 0;
pfd.dwVisibleMask= 0;
pfd.dwDamageMask= 0;
device= GetDC(windowHandle);
if(device== IntPtr.Zero)
{
MessageBox.Show("Can not create a GL device context", "Fatal Error", MessageBoxButtons.OK, MessageBoxIcon.Hand);
Environment.Exit(-1);
}
pixelFormat= ChoosePixelFormat(device, ref pfd);
if(pixelFormat== 0)
{
MessageBox.Show("Can not find a suitable PixelFormat", "Fatal Error", MessageBoxButtons.OK, MessageBoxIcon.Hand);
Environment.Exit(-1);
}
if(!setPixelFormat(device, pixelFormat, ref pfd))
{
MessageBox.Show("Can not set the chosen PixelFormat. Chosen PixelFormat was"+pixelFormat, "Fatal Error", MessageBoxButtons.OK, MessageBoxIcon.Hand);
Environment.Exit(-1);
}
logScaleX= GetDeviceCaps(device, 0x58);
logScaleY= GetDeviceCaps(device, 90);
renderingContext= wglCreateContext(device);
if(renderingContext== IntPtr.Zero)
{
MessageBox.Show("Can not create a GL rendering context", "Fatal Error", MessageBoxButtons.OK, MessageBoxIcon.Hand);
Environment.Exit(-1);
}
makeCurrent();
SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1);
}
private static extern int ChoosePixelFormat(IntPtr pmdevice, ref PixelFormatDescriptor pfd);
static bool InitializeCore()
{
var wndClassEx = new WNDCLASSEX
{
cbSize = Marshal.SizeOf <WNDCLASSEX>(),
hInstance = GetModuleHandle(null),
lpfnWndProc = _wndProcDelegate,
lpszClassName = "AvaloniaGlWindow-" + Guid.NewGuid(),
style = (int)ClassStyles.CS_OWNDC
};
_windowClass = RegisterClassEx(ref wndClassEx);
_bootstrapWindow = CreateOffscreenWindow();
_bootstrapDc = GetDC(_bootstrapWindow);
_defaultPfd = new PixelFormatDescriptor
{
Size = (ushort)Marshal.SizeOf <PixelFormatDescriptor>(),
Version = 1,
Flags = PixelFormatDescriptorFlags.PFD_DRAW_TO_WINDOW |
PixelFormatDescriptorFlags.PFD_SUPPORT_OPENGL | PixelFormatDescriptorFlags.PFD_DOUBLEBUFFER,
DepthBits = 24,
StencilBits = 8,
ColorBits = 32
};
_defaultPixelFormat = ChoosePixelFormat(_bootstrapDc, ref _defaultPfd);
SetPixelFormat(_bootstrapDc, _defaultPixelFormat, ref _defaultPfd);
_bootstrapContext = wglCreateContext(_bootstrapDc);
if (_bootstrapContext == IntPtr.Zero)
{
return(false);
}
wglMakeCurrent(_bootstrapDc, _bootstrapContext);
WglCreateContextAttribsArb = Marshal.GetDelegateForFunctionPointer <WglCreateContextAttribsARBDelegate>(
wglGetProcAddress("wglCreateContextAttribsARB"));
WglChoosePixelFormatArb =
Marshal.GetDelegateForFunctionPointer <WglChoosePixelFormatARBDelegate>(
wglGetProcAddress("wglChoosePixelFormatARB"));
GlDebugMessageCallback =
Marshal.GetDelegateForFunctionPointer <GlDebugMessageCallbackDelegate>(
wglGetProcAddress("glDebugMessageCallback"));
var formats = new int[1];
WglChoosePixelFormatArb(_bootstrapDc, new int[]
{
WGL_DRAW_TO_WINDOW_ARB, 1,
WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
WGL_SUPPORT_OPENGL_ARB, 1,
WGL_DOUBLE_BUFFER_ARB, 1,
WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
WGL_COLOR_BITS_ARB, 32,
WGL_ALPHA_BITS_ARB, 8,
WGL_DEPTH_BITS_ARB, 0,
WGL_STENCIL_BITS_ARB, 0,
0, // End
}, null, 1, formats, out int numFormats);
if (numFormats != 0)
{
DescribePixelFormat(_bootstrapDc, formats[0], Marshal.SizeOf <PixelFormatDescriptor>(), ref _defaultPfd);
_defaultPixelFormat = formats[0];
}
wglMakeCurrent(IntPtr.Zero, IntPtr.Zero);
return(true);
}
public static extern bool SetPixelFormat(IntPtr hdc, int iPixelFormat, PixelFormatDescriptor* ppfd);
