/* void IXwt.SetCapture(Widget widget)
* {
* var wBackend = Xwt.Toolkit.CurrentEngine.GetSafeBackend(widget) as Xwt.WPFBackend.WidgetBackend;
* wBackend.Widget.CaptureMouse();
* }
* void IXwt.ReleaseCapture(Widget widget)
* {
* var wBackend = Xwt.Toolkit.CurrentEngine.GetSafeBackend(widget) as Xwt.WPFBackend.WidgetBackend;
* wBackend.Widget.ReleaseMouseCapture();
* }*/
void IXwtRender.CreateForWidgetContext(IRenderer renderer, IRenderOwner rendererimpl, Canvas widget)
{
// views[widget].
/* var wBackend = Xwt.Toolkit.CurrentEngine.GetSafeBackend(win) as Xwt.WPFBackend.WidgetBackend;
* // var hwndSource = System.Windows.PresentationSource.FromVisual(wBackend.NativeWidget as Visual) as System.Windows.Interop.HwndSource;
* //hwndSource.CompositionTarget.RenderMode = System.Windows.Interop.RenderMode.SoftwareOnly;
* var window = Xwt.Toolkit.CurrentEngine.GetSafeBackend(win.ParentWindow) as Xwt.WPFBackend.WindowFrameBackend;
* var h = new WindowInteropHelper(window.Window).Handle;
* // var hwndSource = System.Windows.PresentationSource.From(window.) as System.Windows.Interop.HwndSource;
* //hwndSource.CompositionTarget.RenderMode = System.Windows.Interop.RenderMode.SoftwareOnly;
*
* var wininf = Utilities.CreateWindowsWindowInfo(h);
*
* var gm = new GraphicsMode(new ColorFormat(8, 8, 8, 0), 24, 8);
* var ctx = new GraphicsContext(gm, wininf, 3, 3, GraphicsContextFlags.Default);
*
* ctx.MakeCurrent(wininf);
* ctx.LoadAll();
*
* views[win] = new viewinfo() { wininf = wininf, ctx = ctx };*/
// widget.BoundsChanged += Widget_BoundsChanged;
this.views[widget] = new viewinfo()
{
renderer = renderer
};
}
void IXwtRender.CreateForWidgetContext(IRenderer renderer, IRenderOwner rendererimpl, Canvas widget)
{
Xwt.Canvas view = null;
IntPtr hwnd;
EventHandler sizefunc = null;
if (Xwt.Toolkit.CurrentEngine.Type == ToolkitType.Wpf)
{
hwnd = GetHwnd(widget.ParentWindow);
}
else
{
hwnd = GetHwndFromGtk(Xwt.Toolkit.CurrentEngine.GetSafeBackend(widget));
if (hwnd == GetHwndFromGtk(widget.ParentWindow))
{
view = new global::Xwt.Canvas()
{
ExpandHorizontal = true, ExpandVertical = true, HorizontalPlacement = WidgetPlacement.Fill, VerticalPlacement = WidgetPlacement.Fill, MinWidth = 1, MinHeight = 1, BackgroundColor = Xwt.Drawing.Colors.Black
};
(widget as global::Xwt.Canvas).AddChild(view);
var viewbackend = Xwt.Toolkit.CurrentEngine.GetSafeBackend(view) as Xwt.Backends.ICanvasBackend;
var gtkview = viewbackend.GetType().GetPropertyValue(viewbackend, "Widget");
gtkview.GetType().SetPropertyValue(gtkview, "DoubleBuffered", false);
hwnd = GetHwndFromGtk(viewbackend);
Debug.Assert(hwnd != GetHwndFromGtk(widget.ParentWindow));
sizefunc = new EventHandler((s, a) => (widget as global::Xwt.Canvas).SetChildBounds(view, new Rectangle(Point.Zero, widget.Size)));
(widget as global::Xwt.Canvas).BoundsChanged += sizefunc;
sizefunc(null, EventArgs.Empty);
}
}
IWindowInfo WindowInfo = null;
IGraphicsContext gfxcontext = null;
WindowInfo = Utilities.CreateWindowsWindowInfo(hwnd);
gfxcontext = new global::OpenTK.Graphics.GraphicsContext(new GraphicsMode(new ColorFormat(8, 8, 8, 8), 24, 8), WindowInfo, null, 3, 2, GraphicsContextFlags.Default);
views[widget] = new viewinfo(WindowInfo, gfxcontext)
{
viewcanvas = view, sizefunc = sizefunc
};
gfxcontext.MakeCurrent(WindowInfo);
gfxcontext.LoadAll();
int major, minor;
GL.GetInteger(GetPName.MajorVersion, out major);
GL.GetInteger(GetPName.MinorVersion, out minor);
Console.WriteLine($"OpenGL {major}.{minor}");
gfxcontext.MakeCurrent(null);
}
/* IRenderer IRendererFactory.Open(object ctl, Xwt.Size videosize)
* {
* throw new NotImplementedException();
* }*/
IRenderer IRendererFactory.Open(IXwtRender xwt, Canvas w, IRenderOwner renderer, FPS fps, size videosize)
{
lock (this)
{
var window = w.ParentWindow;
var wFrame = global::Xwt.Toolkit.CurrentEngine.GetSafeBackend(window);// as global::Xwt.WPFBackend.WindowFrameBackend;
var wBackend = global::Xwt.Toolkit.CurrentEngine.GetSafeBackend(w);
var e = (System.Windows.FrameworkElement)wBackend.GetType().GetPropertyValue(wBackend, "Widget");
return(new DirectX9Renderer(this, xwt, w, e, (System.Windows.Window)wFrame.GetType().GetPropertyValue(wFrame, "Window"), renderer, fps, videosize));
}
}
public viewwindow(IRenderer render, IRenderOwner renderer, Widget widget, CGRect frame, NSOpenGLContext ctx)
: base(frame)
{
this.mainthread = Thread.CurrentThread;
this.render = render;
this.renderer = renderer;
this.window = widget;
base.WantsBestResolutionOpenGLSurface = true;
this.WantsLayer = true;
this.openglctx = ctx;
Trace.Assert(this.openglctx != null, "no NSOpenGLContext context");
// this.openglctx.CGLContext.Handle
this.openglctx.CGLContext.Lock();
try
{
this.openglctx.MakeCurrentContext();
this._ctx = new _GraphicsContext(); // created from active content
}
catch { throw; }
finally
{
NSOpenGLContext.ClearCurrentContext();
this.openglctx.CGLContext.Unlock();
}
/* var wBackend = Xwt.Toolkit.CurrentEngine.GetSafeBackend(widget.ParentWindow) as Xwt.Backends.IWindowFrameBackend;
* var win = wBackend.Window as NSWindow;
*
* while (win.ParentWindow != null)
* {
* win = win.ParentWindow;
* }
* // win.DidChangeValue+= Win_DidChangeValue;
* win.DidChangeBackingProperties+= Win_DidChangeBackingProperties;
* win.DidChangeScreenProfile+= Win_DidChangeScreenProfile;
* win.DidExpose+= Win_DidExpose;
* win.DidMiniaturize+= Win_DidMiniaturize;
* win.DidChangeScreen+= Win_DidChangeScreen;*/
}
void IXwtRender.CreateForWidgetContext(IRenderer renderer, IRenderOwner rendererimpl, Canvas widget)
{
var o = Xwt.Toolkit.CurrentEngine.GetSafeBackend(widget);
var wBackend = Xwt.Toolkit.CurrentEngine.GetSafeBackend(widget) as Xwt.Backends.IWidgetBackend;
// var nsWindow = wBackend.NativeHandle;l;
var nsView = (wBackend.NativeWidget as NSView);
var ctx = new NSOpenGLContext(GetOpenGLPixelFormat(0), null);
var error = viewwindow.layer.CGLEnable(ctx.CGLContext.Handle, 313); // enable multithread
viewwindow view = null;
// ctx.CGLContext.Lock();
// ctx.MakeCurrentContext();
Application.InvokeAsync(() =>
{
view = new viewwindow(renderer, rendererimpl, widget, ViewPostion(widget, wBackend), ctx);
nsView.AddSubview(view);
Debug.Assert(!views.ContainsKey(widget));
views[widget] = new viewinfo()
{
orgview = nsView, /* backend = wBackend,*/ myview = view, widget = widget
};
widget.BoundsChanged += sizechanged;
}).Wait();
/* (this as IXwtRender).StartRender(renderer, widget);
* view._ctx = new _GraphicsContext();
* (this as IXwtRender).EndRender(renderer, widget);*/
this.QueueOnUI(() => view.initdone.Set());
}
internal OpenTKRenderer(FrameFactory owner, IXwtRender xwtrender, Xwt.Canvas window, IRenderOwner renderer, size videosize)
{
// OpenTKRenderer.usecnt = 1;
this.owner = owner;
this.Xwt = xwtrender;
this.videosize = videosize;
this.window = window;
this.renderer = renderer;
this.viewsize = window.Size;
window.BoundsChanged += viewsizechanged;
this.actionthread = new Thread(run)
{
Name = "opentk"
};
this.actionthread.Start();
var _this = this;
this.Xwt.CreateForWidgetContext(this, this.renderer, window);
// Invoke(() =>
// {
this.Lock(false);
try
{
try
{
// GL.GetInternalformat(TextureTarget.Texture2D, SizedInternalFormat.Rgba8, InternalFormatParameter..TEXTUREIMAGEFORMAT, 1, &preferred_format).
this.vertices1 = new vertices(_vertices);
this.vertices2 = new vertices(_vertices2);
/* GL.GenBuffers(1, out buf_vertices2); // Generate 1 buffer
* GL.BindBuffer(BufferTarget.ArrayBuffer, buf_vertices2);
* GL.VertexAttribPointer(0, 2, VertexAttribPointerType.Float, false, 4 * sizeof(float), 0);
* GL.VertexAttribPointer(1, 2, VertexAttribPointerType.Float, false, 4 * sizeof(float), 2 * sizeof(float));
* GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * vertices2.Length, vertices2, BufferUsageHint.StaticDraw);
* GL.EnableVertexAttribArray(0);
* GL.EnableVertexAttribArray(1);
*
* GL.GenBuffers(1, out buf_vertices3); // Generate 1 buffer
* GL.BindBuffer(BufferTarget.ArrayBuffer, buf_vertices3);
* GL.VertexAttribPointer(0, 2, VertexAttribPointerType.Float, false, 4 * sizeof(float), 0);
* GL.VertexAttribPointer(1, 2, VertexAttribPointerType.Float, false, 4 * sizeof(float), 2 * sizeof(float));
* GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * vertices3.Length, vertices3, BufferUsageHint.StaticDraw);
* GL.EnableVertexAttribArray(0);
* GL.EnableVertexAttribArray(1);*/
// GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
/* this.presentshader = new shader(shadervertex, shaderfragment, vertices1);
* GL.UseProgram(this.presentshader);
* var pos = GL.GetUniformLocation(this.presentshader, "tex");
* GL.Uniform1(pos, 0);
*/
/* this.combineshader = new shader(combineshadervertex, combineshaderfragment, vertices1);
*
* GL.UseProgram(combineshader);
* var pos = GL.GetUniformLocation(this.combineshader, "tex");
* GL.Uniform1(pos, 0);
* pos = GL.GetUniformLocation(this.combineshader, "vpHeight");
* GL.Uniform1(pos, (float)videosize.height);
*
* this.deinterlaceblendshader = new shader(combineshadervertex, blendshaderfragment, vertices1);
* GL.UseProgram(deinterlaceblendshader);
* pos = GL.GetUniformLocation(this.deinterlaceblendshader, "vpHeight");
* GL.Uniform1(pos, (float)videosize.height);
*
* this.deinterlacesplitshader = new shader(combineshadervertex, splitshaderfragment, vertices1);
*
* GL.UseProgram(deinterlacesplitshader);
* pos = GL.GetUniformLocation(this.deinterlacesplitshader, "vpHeight");
* GL.Uniform1(pos, (float)videosize.height);*/
}
catch (Exception e)
{
// Log.LogException(e);
Dispose(true);
GC.SuppressFinalize(this);
throw;
}
}
finally
{
Unlock(false);
}
// });
}
void IXwtRender.CreateForWidgetContext(IRenderer renderer, IRenderOwner rendererimpl, Canvas widget)
{
impl.CreateForWidgetContext(renderer, rendererimpl, widget);
}
void IXwtRender.CreateForWidgetContext(IRenderer renderer, IRenderOwner rendererimpl, Canvas widget)
{
var wBackend = Xwt.Toolkit.CurrentEngine.GetSafeBackend(widget) as Xwt.Backends.ICanvasBackend;
var gtkwidget = wBackend.GetType().GetPropertyValue(wBackend, "Widget");
gtkwidget.GetType().SetPropertyValue(gtkwidget, "DoubleBuffered", false);
// var widget = wBackend.GetType().GetPropertyValue(wBackend, "Widget");
// widget.GetType().SetPropertyValue(widget, "DoubleBuffered", false);
// var gdkwin = widget.GetType().GetPropertyValue(widget, "GdkWindow");
var h = GetHandle(wBackend); // (IntPtr)gdkwin.GetType().GetPropertyValue(gdkwin, "Handle");
IntPtr windowHandle = gdk_x11_drawable_get_xid(h); // wBackend.Widget.Handle
IntPtr display2 = gdk_drawable_get_display(h);
IntPtr display = gdk_x11_drawable_get_xdisplay(h);
IntPtr screen = gdk_display_get_default_screen(display2);
int screenn = gdk_screen_get_number(screen);
IntPtr rootWindow = gdk_screen_get_root_window(screen);
IntPtr visualInfo = IntPtr.Zero;
XVisualInfo info = new XVisualInfo();
info.VisualID = IntPtr.Zero;
int dummy;
visualInfo = XGetVisualInfo(display, XVisualInfoMask.ID, ref info, out dummy);
// }
/* else
* {
* visualInfo = GetVisualInfo(display);
* }*/
var wBackendMain = Xwt.Toolkit.CurrentEngine.GetSafeBackend(widget.ParentWindow) as Xwt.Backends.IWindowFrameBackend;
var winmain = wBackendMain.GetType().GetPropertyValue(wBackendMain, "Window");
var gdkwinmain = winmain.GetType().GetPropertyValue(winmain, "GdkWindow");
var hmain = (IntPtr)gdkwinmain.GetType().GetPropertyValue(gdkwinmain, "Handle");
Canvas view = null;
EventHandler sizefunc = null;
if (h == hmain)
{
view = new global::Xwt.Canvas()
{
ExpandHorizontal = true, ExpandVertical = true, HorizontalPlacement = WidgetPlacement.Fill, VerticalPlacement = WidgetPlacement.Fill, MinWidth = 1, MinHeight = 1, BackgroundColor = Xwt.Drawing.Colors.Black
};
widget.AddChild(view);
var viewbackend = Xwt.Toolkit.CurrentEngine.GetSafeBackend(view) as Xwt.Backends.ICanvasBackend;
var gtkview = viewbackend.GetType().GetPropertyValue(viewbackend, "Widget");
gtkview.GetType().SetPropertyValue(gtkview, "DoubleBuffered", false);
var hwnd = GetHandle(viewbackend);
Debug.Assert(hwnd != hmain);
sizefunc = new EventHandler((s, a) => widget.SetChildBounds(view, new Rectangle(Point.Zero, widget.Size)));
widget.BoundsChanged += sizefunc;
sizefunc(null, EventArgs.Empty);
windowHandle = gdk_x11_drawable_get_xid(hwnd);
}
var WindowInfo = Utilities.CreateX11WindowInfo(display, screenn, windowHandle, rootWindow, visualInfo);
XFree(visualInfo);
var gfxcontext = new OpenTK.Graphics.GraphicsContext(new GraphicsMode(new ColorFormat(8, 8, 8, 8), 24, 8), WindowInfo, 3, 3, GraphicsContextFlags.Default);
views[widget] = new viewinfo(WindowInfo, gfxcontext, (gfxcontext as IGraphicsContextInternal).Context)
{
view = view, sizefunc = sizefunc
};
gfxcontext.MakeCurrent(WindowInfo);
gfxcontext.LoadAll();
int major, minor;
GL.GetInteger(GetPName.MajorVersion, out major);
GL.GetInteger(GetPName.MinorVersion, out minor);
Console.WriteLine("OpenGL {0}.{1}", major, minor);
gfxcontext.MakeCurrent(null);
}
internal DirectX9Renderer(FrameFactory owner, IXwtRender xwt, Canvas widget, System.Windows.FrameworkElement window, System.Windows.Window main, IRenderOwner renderer, FPS fps, size videosize)
{
this.owner = owner;
this.xwt = xwt;
this.widget = widget;
this.window = window as System.Windows.Controls.Panel;
this.mainwindow = main;
this.videosize = videosize;
this.renderer = renderer;
var w = System.Windows.Window.GetWindow(this.mainwindow);
var h = new WindowInteropHelper(w);
this.hwnd = h.Handle;
/* mainwindow.Measure(new System.Windows.Size(double.PositiveInfinity, double.PositiveInfinity));
* mainwindow.Arrange(new Rect(0, 0, mainwindow.Width, mainwindow.Height));
*
* this.window.Arrange(ew Rect(0, 0, this.window.ActualWidth, this.window.ActualHeight));*/
//window..CompositionTarget
// OpenTKRenderer.usecnt = 1; // this.ctlhandle = this.ctl.Handle;
this.viewsize = new size(Convert.ToInt32(window.ActualWidth), Convert.ToInt32(window.ActualHeight));
this.window.SizeChanged += Ctl_SizeChanged;
xwt.CreateForWidgetContext(this, renderer, widget);
this.opentk = this.owner.opentk.Open(this.owner.opentkxwt, widget, renderer, fps, videosize);
this.thread = new WorkerThread();
this.thread.Do(() =>
{
// System.Drawing.Rectangle r = new System.Drawing.Rectangle(System.Drawing.Point.Empty, this.viewsize);// Win32Helper.GetClientRect(ctlhandle);
// this.lastsize = new System.Drawing.Size(r.Width, r.Height);
this.pp = new PresentParameters(this.videosize.width, this.videosize.height);
pp.DeviceWindowHandle = this.hwnd;
pp.EnableAutoDepthStencil = true;
pp.SwapEffect = SwapEffect.Copy;
pp.PresentationInterval = PresentInterval.Immediate;
try
{
/* this.direct3D = new Direct3DEx();
* this.isex = true;
* this.device = new DeviceEx(this.direct3D as Direct3DEx, 0, DeviceType.Hardware, this.hwnd, CreateFlags.Multithreaded | CreateFlags.HardwareVertexProcessing, pp);*/
}
catch
{
if (this.direct3D != null)
{
throw;
}
}
if (this.direct3D == null)
{
this.direct3D = new Direct3D();
this.device = new Device(this.direct3D, 0, DeviceType.Hardware, this.hwnd, CreateFlags.Multithreaded | CreateFlags.HardwareVertexProcessing, pp);
}
this.depthtexture = new Texture(this.device, 4096, 4096, 1, Usage.DepthStencil, Format.D24S8, Pool.Default);
this.depthsurface = this.depthtexture.GetSurfaceLevel(0);
this.olddepth = this.device.DepthStencilSurface;
this.device.DepthStencilSurface = this.depthsurface;
// this.lastsize = r.Size;
// Compiles the effect
this.presenteffect = _LoadEffect("render");// Effect.FromFile(device, "render.fx", ShaderFlags.None);
this.technique = presenteffect.GetTechnique(0);
this.effect2 = _LoadEffect("render2");
this.technique2 = effect2.GetTechnique(0);
this.effect3 = _LoadEffect("render3");
// Get the technique
// Prepare matrices
// Creates and sets the Vertex Declaration
this.vertexDecl2 = new VertexDeclaration(device, vertexElems2);
// device.SetStreamSource(0, vertices2, 0, Utilities.SizeOf<vertex>());
// device.VertexDeclaration = vertexDecl2;
this.vertices2 = new VertexBuffer(device, Utilities.SizeOf <vertex>() * 6, Usage.WriteOnly, VertexFormat.None, isex ? Pool.Default : Pool.Managed);
vertices2.Lock(0, 0, LockFlags.None).WriteRange(this.initdata);
vertices2.Unlock();
this.indices = new IndexBuffer(device, sizeof(int) * initdata2.Length, Usage.WriteOnly, isex ? Pool.Default : Pool.Managed, false);
this.indices.Lock(0, 0, LockFlags.None).WriteRange(this.initdata2);
this.indices.Unlock();
this.frame = new VideoFrame(this);
this.frame.Set(opentk.AlphaFormat);
});
this._layer = new layer(this);
this._layer?.rec.Arrange(new Rect(0, 0, this.window.ActualWidth, this.window.ActualHeight));
this.window.Children.Add((FrameworkElement)_layer);
//this.initdone.Set();
}
