protected override void OnReadyForInitGLShaderProgram()
{
_surface1 = new GLRenderSurface(_pcx.ViewportWidth, _pcx.ViewportHeight);
_frameBufferNeedUpdate = true;
//------------
_surface2 = new GLRenderSurface(_pcx.ViewportWidth, _pcx.ViewportHeight);
}
GLBitmap ConvertFromBGRA_To_RGBA(GLBitmap bgraBmp)
{
GLBitmap rgba_result = new GLBitmap(bgraBmp.Width, bgraBmp.Height);//create another from blank with the same size
using (GLRenderSurface surface1 = new GLRenderSurface(bgraBmp.Width, bgraBmp.Height))
using (GLRenderSurface surface2 = new GLRenderSurface(rgba_result, false))
{
_pcx.AttachToRenderSurface(surface1);
_pcx.OriginKind = PixelFarm.Drawing.RenderSurfaceOrientation.LeftTop;
//------------------------------------------------------------------------------------
//after make the frameBuffer current
//then all drawing command will apply to frameBuffer
//do draw to frame buffer here
_pcx.Clear(PixelFarm.Drawing.Color.Black);
_pcx.DrawImage(bgraBmp, 0, 0);
//------------------------------------------------------------------------------------
_pcx.AttachToRenderSurface(null);
//after release current, we move back to default frame buffer again***
_pcx.AttachToRenderSurface(surface2);
_pcx.OriginKind = PixelFarm.Drawing.RenderSurfaceOrientation.LeftTop;
_pcx.Clear(PixelFarm.Drawing.Color.Black);
_pcx.DrawImage(surface1.GetGLBitmap(), 0, 0);
_pcx.AttachToRenderSurface(null);
}
return(rgba_result);
}
public override void Dispose()
{
if (_glRenderSurface != null)
{
_glRenderSurface.Dispose();
_glRenderSurface = null;
}
}
public static GLRenderSurface CreateGLRenderSurface(int w, int h, int viewportW, int viewportH)
{
//the canvas may need some init modules
//so we start the canvass internaly here
var glsx = new GLRenderSurface(w, h);
glsx.SetViewport(viewportW, viewportH);
return(glsx);
}
protected override void OnReadyForInitGLShaderProgram()
{
int max = Math.Max(this.Width, this.Height);
_surface1 = new GLRenderSurface(max, max);
}
protected override void OnGLSurfaceReady(GLRenderSurface glsx, GLPainter painter)
{
this._glsx = glsx;
this.painter = painter;
}
protected override void OnReadyForInitGLShaderProgram()
{
_surface1 = new GLRenderSurface(this.Width, this.Height);
_frameBufferNeedUpdate = true;
}
public static void InvokeGLContextReady(DemoBase demo, GLRenderSurface glsx, GLPainter painter)
{
demo._painter = painter;
demo.OnGLSurfaceReady(glsx, painter);
demo.OnReadyForInitGLShaderProgram();
}
//----------------------------------------------------
//for GL
public virtual void BuildCustomDemoGLContext(out GLRenderSurface glsx, out GLPainter painter)
{
glsx = null;
painter = null;
}
protected virtual void OnGLSurfaceReady(GLRenderSurface glsx, GLPainter painter)
{
}
public MyGLBackbuffer(int w, int h, bool useRGB = false)
{
_w = w;
_h = h;
_glRenderSurface = new GLRenderSurface(w, h, useRGB ? BitmapBufferFormat.RGBO : BitmapBufferFormat.RGBA);
}
public void InitRootGraphics(
RootGraphic rootgfx,
ITopWindowEventRoot topWinEventRoot,
InnerViewportKind innerViewportKind)
{
//create a proper bridge****
this.rootgfx = rootgfx;
this.topWinEventRoot = topWinEventRoot;
this.innerViewportKind = innerViewportKind;
switch (innerViewportKind)
{
case InnerViewportKind.GL:
{
#if GL_ENABLE
//temp not suppport
//TODO: review here
//PixelFarm.Drawing.DrawingGL.CanvasGLPortal.Start();
var bridge = new OpenGL.MyTopWindowBridgeOpenGL(rootgfx, topWinEventRoot);
var view = new OpenGL.GpuOpenGLSurfaceView();
view.Width = 1200;
view.Height = 1200;
openGLSurfaceView = view;
//view.Dock = DockStyle.Fill;
//this.Controls.Add(view);
this.panel1.Visible = true;
this.panel1.Controls.Add(view);
//---------------------------------------
view.Bind(bridge);
this.winBridge = bridge;
//---------------------------------------
view.SetGLPaintHandler(null);
hh1 = view.Handle; //force real window handle creation
view.MakeCurrent();
int max = Math.Max(view.Width, view.Height);
_glsx = PixelFarm.Drawing.GLES2.GLES2Platform.CreateGLRenderSurface(max, max, view.Width, view.Height);
//---------------
//canvas2d.FlipY = true;//
//---------------
canvasPainter = new GLPainter(_glsx);
//canvasPainter.SmoothingMode = PixelFarm.Drawing.SmoothingMode.HighQuality;
//----------------------
//1. win gdi based
//var printer = new WinGdiFontPrinter(canvas2d, view.Width, view.Height);
//canvasPainter.TextPrinter = printer;
//----------------------
//2. raw vxs
//var printer = new PixelFarm.Drawing.Fonts.VxsTextPrinter(canvasPainter);
//canvasPainter.TextPrinter = printer;
//----------------------
//3. agg texture based font texture
//var printer = new AggTextSpanPrinter(canvasPainter, 400, 50);
//printer.HintTechnique = Typography.Rendering.HintTechnique.TrueTypeInstruction_VerticalOnly;
//printer.UseSubPixelRendering = true;
//canvasPainter.TextPrinter = printer;
//3
var printer = new GLBitmapGlyphTextPrinter(canvasPainter, PixelFarm.Drawing.GLES2.GLES2Platform.TextService);
canvasPainter.TextPrinter = printer;
//
var myGLCanvas1 = new PixelFarm.Drawing.GLES2.MyGLDrawBoard(canvasPainter, _glsx.CanvasWidth, _glsx.CanvasHeight);
bridge.SetCanvas(myGLCanvas1);
#endif
}
break;
#if __SKIA__
case InnerViewportKind.Skia:
{
//skiasharp ***
var bridge = new Skia.MyTopWindowBridgeSkia(rootgfx, topWinEventRoot);
var view = new CpuSurfaceView();
view.Dock = DockStyle.Fill;
this.Controls.Add(view);
//---------------------------------------
view.Bind(bridge);
this.winBridge = bridge;
}
break;
#endif
case InnerViewportKind.GdiPlus:
default:
{
var bridge = new GdiPlus.MyTopWindowBridgeGdiPlus(rootgfx, topWinEventRoot);
var view = new CpuSurfaceView();
view.Dock = DockStyle.Fill;
this.Controls.Add(view);
//---------------------------------------
view.Bind(bridge);
this.winBridge = bridge;
}
break;
}
}
protected override void OnGLRender(object sender, EventArgs args)
{
//reset
_pcx.SmoothMode = SmoothMode.Smooth;
_pcx.ClearColorBuffer();
_painter.Clear(Color.Yellow);
switch (DrawSet)
{
case T408_DrawSet.A:
{
//draw msdf bitmap to mask surface
if (_maskRenderSurface == null)
{
GLRenderSurface currentSurface = _pcx.CurrentRenderSurface;
_maskRenderSurface = new GLRenderSurface(100, 100);
_pcx.AttachToRenderSurface(_maskRenderSurface);
//draw mask
_pcx.Clear(Color.Black);
_pcx.DrawImageWithMsdf(_msdfMaskGLBmp, 0, 0, 5, Color.White);
//switch back to normal surface
_pcx.AttachToRenderSurface(currentSurface);
}
//render with simple mask
_pcx.DrawImageWithMask(
_maskRenderSurface.GetInnerGLData().GLBmp,
_colorGLBmp, 0, 0);
}
break;
case T408_DrawSet.B:
{
RectangleF maskSrc = new RectangleF(0, 0, _msdfMaskBmp.Width, _msdfMaskBmp.Height);
Rectangle rect = new Rectangle(10, 10, 120, 120);
Quad2f quad = new Quad2f();
quad.SetCornersFromRect(rect);
AffineMat mat1 = AffineMat.Iden();
mat1.Translate(-rect.Width / 2, -rect.Height / 2);
mat1.RotateDeg(45);
mat1.Translate(rect.Width / 2, rect.Height / 2);
quad.Transform(mat1); //***test transform
//-----------------------
//create mask surface, this quite low leve step.
//user should use this through drawboard
//-----------------------
if (_maskRenderSurface2 == null)
{
//before we switch to another GLRenderSurface.
//we save current setting of current GLRenderSurface
_pcx.SaveStates(out GLPainterStatesData saveData1);
_maskRenderSurface2 = new GLRenderSurface(100, 100);
_pcx.AttachToRenderSurface(_maskRenderSurface2);
_pcx.OriginKind = PixelFarm.Drawing.RenderSurfaceOriginKind.LeftTop;
//draw mask
_pcx.Clear(Color.Black);
//draw image to specific quad
_pcx.DrawImageWithMsdf(_msdfMaskGLBmp, quad, Color.White);
//switch back to normal surface
_pcx.RestoreStates(saveData1);
}
_pcx.DrawImageWithMask(
_maskRenderSurface2.GetInnerGLData().GLBmp,
_colorGLBmp, 20, 20);
}
break;
}
SwapBuffers();
}
public void LoadSample(DemoBase demobase)
{
this.demobase = demobase;
//1.
//note:when we init,
//no glcanvas/ painter are created
demobase.Init();
//-----------------------------------------------
//2. check if demo will create canvas/painter context
//or let this GLDemoContext create for it
hh1 = glControl.Handle; //ensure that contrl handler is created
glControl.MakeCurrent();
demobase.BuildCustomDemoGLContext(out this._glsx, out this.canvasPainter);
//
if (this._glsx == null)
{
//if demo not create canvas and painter
//the we create for it
int max = Math.Max(glControl.Width, glControl.Height);
_glsx = PixelFarm.Drawing.GLES2.GLES2Platform.CreateGLRenderSurface(max, max, glControl.Width, glControl.Height);
_glsx.SmoothMode = SmoothMode.Smooth;//set anti-alias
canvasPainter = new GLPainter(_glsx);
//create text printer for opengl
//----------------------
//1. win gdi based
//var printer = new WinGdiFontPrinter(_glsx, glControl.Width, glControl.Height);
//canvasPainter.TextPrinter = printer;
//----------------------
//2. raw vxs
//var openFontStore = new Typography.TextServices.OpenFontStore();
//var printer = new PixelFarm.Drawing.Fonts.VxsTextPrinter(canvasPainter,openFontStore);
//canvasPainter.TextPrinter = printer;
//----------------------
//3. agg texture based font texture
//var printer = new AggTextSpanPrinter(canvasPainter, glControl.Width, 30);
//canvasPainter.TextPrinter = printer;
//----------------------
//4. texture atlas based font texture
//------------
//resolve request font
var printer = new GLBitmapGlyphTextPrinter(canvasPainter, PixelFarm.Drawing.GLES2.GLES2Platform.TextService);
canvasPainter.TextPrinter = printer;
//var openFontStore = new Typography.TextServices.OpenFontStore();
//var printer = new GLBmpGlyphTextPrinter(canvasPainter, openFontStore);
//canvasPainter.TextPrinter = printer;
}
//-----------------------------------------------
demobase.SetEssentialGLHandlers(
() => this.glControl.SwapBuffers(),
() => this.glControl.GetEglDisplay(),
() => this.glControl.GetEglSurface()
);
//-----------------------------------------------
this.glControl.SetGLPaintHandler((s, e) =>
{
demobase.InvokeGLPaint();
});
DemoBase.InvokeGLContextReady(demobase, this._glsx, this.canvasPainter);
DemoBase.InvokePainterReady(demobase, this.canvasPainter);
}
