public void display_pmap(Graphics displayGraphics, RasterBuffer src) { if (m_sys_format == m_format) { m_pmap_window.Draw(displayGraphics); } else { PixelMap pmap_tmp = new PixelMap(); pmap_tmp.Create(m_pmap_window.Width(), m_pmap_window.Height(), PlatformSupportAbstract.GetBitDepthForPixelFormat(m_sys_format)); RasterBuffer rbuf_tmp = new RasterBuffer(); unsafe { rbuf_tmp.Attach(pmap_tmp.buf(), pmap_tmp.Width(), pmap_tmp.Height(), m_app.FlipY() ? pmap_tmp.stride() : -pmap_tmp.stride(), pmap_tmp.bpp()); } convert_pmap(rbuf_tmp, src, m_format); pmap_tmp.Draw(displayGraphics); throw new System.NotImplementedException(); } }
//-------------------------------------------------------------------- //-------------------------------------------------------------------- public FormatGray(RasterBuffer rb, IBlenderGray blender, uint step, uint offset) { m_rbuf = rb; Blender = blender; m_Step = step; m_Offset = offset; }
public static void CreateContext(RasterBuffer renderingBuffer) { // set the rendering buffer and all the GL default states (this is also where you can new anything you need) s_RenderingBuffer = renderingBuffer; s_Rasterizer.SetVectorClipBox(M.Zero <T>(), M.Zero <T>(), M.New <T>(s_RenderingBuffer.Width), M.New <T>(s_RenderingBuffer.Height)); s_PixelFormt = new FormatRGBA(s_RenderingBuffer, new BlenderBGRA()); s_ClippingPixelFormatProxy = new FormatClippingProxy(s_PixelFormt); //s_ClippingPixelFormatProxy = s_PixelFormt; m_CurAccumulatedMatrix = MatrixFactory <T> .NewIdentity(VectorDimension.Three); // new Matrix4X4(); m_ModelviewMatrix = MatrixFactory <T> .NewIdentity(VectorDimension.Three); // new Matrix4X4(); m_ProjectionMatrix = MatrixFactory <T> .NewIdentity(VectorDimension.Three); //new Matrix4X4(); m_pVertexCache = new VertexCachItem[m_MaxVertexCacheItems]; for (int i = 0; i < m_MaxVertexCacheItems; i++) { m_pVertexCache[i] = new VertexCachItem(); } m_LastSetColor = new RGBA_Doubles(1, 1, 1, 1); m_LastSetNormal = MatrixFactory <T> .CreateZeroVector(VectorDimension.Three); // new Vector3D(); m_LastSetTextureCoordinate = MatrixFactory <T> .CreateZeroVector(VectorDimension.Two); // new Vector2D(); }
public unsafe override void Generate(RGBA_Bytes *span, int x, int y, uint len) { RasterBuffer pSourceRenderingBuffer = base.Source().PixelFormat.GetRenderingBuffer(); ISpanInterpolator <T> spanInterpolator = base.Interpolator; spanInterpolator.Begin(M.New <T>(x).Add(base.FilterDxDbl()), M.New <T>(y).Add(base.FilterDyDbl()), len); do { int x_hr; int y_hr; spanInterpolator.Coordinates(out x_hr, out y_hr); int x_lr = x_hr >> (int)image_subpixel_scale_e.Shift; int y_lr = y_hr >> (int)image_subpixel_scale_e.Shift; byte *fg_ptr = pSourceRenderingBuffer.GetPixelPointer(y_lr) + (x_lr << 2); //byte* fg_ptr = spanInterpolator.span(x_lr, y_lr, 1); //(*span).R = fg_ptr[OrderR]; //(*span).G = fg_ptr[OrderG]; //(*span).B = fg_ptr[OrderB]; //(*span).A = fg_ptr[OrderA]; (*span) = new RGBA_Bytes(fg_ptr[OrderR], fg_ptr[OrderG], fg_ptr[OrderB], fg_ptr[OrderA]); ++span; spanInterpolator.Next(); } while (--len != 0); }
protected override void DoDraw(RendererBase <T> destRenderer) { Image <T> imageToDraw = ImageSequenceReference.Instance.GetImageByTime(m_TotalSeconds); //Image imageToDraw = m_PlayerShipSequence.GetImageByIndex(m_ImageIndex); //IBlender blender = new BlenderBGRA(); IBlender blender = new BlenderAddativeBGR(); unsafe { RasterBuffer destBuffer = destRenderer.PixelFormat.GetRenderingBuffer(); byte * pPixels = destBuffer.GetPixelPointer(200); byte[] sourceBuffer = imageToDraw.ImageBuffer; for (int y = 0; y < imageToDraw.Height; y++) { int SourceYOffset = y * imageToDraw.ScanWidthInBytes; int destYOffset = (int)destBuffer.StrideInBytesAbs * y; for (int x = 0; x < imageToDraw.Width; x++) { int sourceOffset = SourceYOffset + x * 4; blender.BlendPix(&pPixels[destYOffset + x * 4], sourceBuffer[sourceOffset + 2], sourceBuffer[sourceOffset + 1], sourceBuffer[sourceOffset + 0], sourceBuffer[sourceOffset + 3]); } } } }
public void CopyFrom(RasterBuffer sourceBuffer, int xdst, int ydst, int xsrc, int ysrc, uint len) { unsafe { Basics.memmove(&_rasterBuffer.GetPixelPointer(ydst)[xdst * 3], &sourceBuffer.GetPixelPointer(ysrc)[xsrc * 3], (int)len * 3); } }
public unsafe void PixelHighRes(RasterBuffer buf, RGBA_Bytes *p, int x, int y) { int r, g, b, a; r = g = b = a = LineAABasics.LineSubPixelScale * LineAABasics.LineSubPixelScale / 2; int weight; int x_lr = x >> LineAABasics.LineSubPixelShift; int y_lr = y >> LineAABasics.LineSubPixelShift; x &= LineAABasics.LineSubPixelMask; y &= LineAABasics.LineSubPixelMask; RGBA_Bytes *ptr = (RGBA_Bytes *)buf.GetPixelPointer(x_lr, y_lr); weight = (LineAABasics.LineSubPixelScale - x) * (LineAABasics.LineSubPixelScale - y); r += weight * ptr->R; g += weight * ptr->G; b += weight * ptr->B; a += weight * ptr->A; ++ptr; weight = x * (LineAABasics.LineSubPixelScale - y); r += weight * ptr->R; g += weight * ptr->G; b += weight * ptr->B; a += weight * ptr->A; ptr = (RGBA_Bytes *)buf.GetPixelPointer(x_lr, y_lr + 1); weight = (LineAABasics.LineSubPixelScale - x) * y; r += weight * ptr->R; g += weight * ptr->G; b += weight * ptr->B; a += weight * ptr->A; ++ptr; weight = x * y; r += weight * ptr->R; g += weight * ptr->G; b += weight * ptr->B; a += weight * ptr->A; //p->R = (byte)(r >> LineAABasics.LineSubPixelShift * 2); //p->G = (byte)(g >> LineAABasics.LineSubPixelShift * 2); //p->B = (byte)(b >> LineAABasics.LineSubPixelShift * 2); //p->A = (byte)(a >> LineAABasics.LineSubPixelShift * 2); (*p) = new RGBA_Bytes( (byte)(r >> LineAABasics.LineSubPixelShift * 2), (byte)(g >> LineAABasics.LineSubPixelShift * 2), (byte)(b >> LineAABasics.LineSubPixelShift * 2), (byte)(a >> LineAABasics.LineSubPixelShift * 2)); }
public unsafe void create_pmap(uint width, uint height, RasterBuffer wnd) { m_pmap_window = new PixelMap(); m_pmap_window.Create(width, height, PlatformSupportAbstract.GetBitDepthForPixelFormat(m_format)); wnd.Attach(m_pmap_window.buf(), m_pmap_window.Width(), m_pmap_window.Height(), m_RenderOrigin == PlatformSupportAbstract.ERenderOrigin.OriginBottomLeft ? -m_pmap_window.stride() : m_pmap_window.stride(), m_pmap_window.bpp()); }
public unsafe void PixelHighRes(RasterBuffer buf, RGBA_Bytes* p, int x, int y) { int r, g, b, a; r = g = b = a = LineAABasics.LineSubPixelScale * LineAABasics.LineSubPixelScale / 2; int weight; int x_lr = x >> LineAABasics.LineSubPixelShift; int y_lr = y >> LineAABasics.LineSubPixelShift; x &= LineAABasics.LineSubPixelMask; y &= LineAABasics.LineSubPixelMask; RGBA_Bytes* ptr = (RGBA_Bytes*)buf.GetPixelPointer(x_lr, y_lr); weight = (LineAABasics.LineSubPixelScale - x) * (LineAABasics.LineSubPixelScale - y); r += weight * ptr->R; g += weight * ptr->G; b += weight * ptr->B; a += weight * ptr->A; ++ptr; weight = x * (LineAABasics.LineSubPixelScale - y); r += weight * ptr->R; g += weight * ptr->G; b += weight * ptr->B; a += weight * ptr->A; ptr = (RGBA_Bytes*)buf.GetPixelPointer(x_lr, y_lr + 1); weight = (LineAABasics.LineSubPixelScale - x) * y; r += weight * ptr->R; g += weight * ptr->G; b += weight * ptr->B; a += weight * ptr->A; ++ptr; weight = x * y; r += weight * ptr->R; g += weight * ptr->G; b += weight * ptr->B; a += weight * ptr->A; //p->R = (byte)(r >> LineAABasics.LineSubPixelShift * 2); //p->G = (byte)(g >> LineAABasics.LineSubPixelShift * 2); //p->B = (byte)(b >> LineAABasics.LineSubPixelShift * 2); //p->A = (byte)(a >> LineAABasics.LineSubPixelShift * 2); (*p) = new RGBA_Bytes( (byte)(r >> LineAABasics.LineSubPixelShift * 2), (byte)(g >> LineAABasics.LineSubPixelShift * 2), (byte)(b >> LineAABasics.LineSubPixelShift * 2), (byte)(a >> LineAABasics.LineSubPixelShift * 2)); }
// Create //-------------------------------------------------------------------- public line_image_pattern(IPatternFilter filter, RasterBuffer src) { m_filter = (filter); m_dilation = (filter.dilation() + 1); m_dilation_hr = (m_dilation << LineAABasics.line_subpixel_shift); m_width = 0; m_height = 0; m_width_hr = 0; m_half_height_hr = 0; m_offset_y_hr = (0); m_buf = src; create(src); }
public void CopyFrom(RasterBuffer sourceBuffer, int xdst, int ydst, int xsrc, int ysrc, uint len) { unsafe { byte *pSource = sourceBuffer.GetPixelPointer(ysrc); if (pSource != null) { int BytesPerScanLine = Stride; Basics.memmove(m_rbuf.GetPixelPointer(ydst) + xdst * BytesPerScanLine, pSource + xsrc * BytesPerScanLine, (int)len * BytesPerScanLine); } } }
public unsafe void PixelHighResolution(RasterBuffer buf, RGBA_Bytes *p, int x, int y) { int r, g, b, a; r = g = b = a = LineAABasics.line_subpixel_scale * LineAABasics.line_subpixel_scale / 2; int weight; int x_lr = x >> LineAABasics.line_subpixel_shift; int y_lr = y >> LineAABasics.line_subpixel_shift; x &= LineAABasics.line_subpixel_mask; y &= LineAABasics.line_subpixel_mask; RGBA_Bytes *ptr = (RGBA_Bytes *)buf.GetPixelPointer(x_lr, y_lr); weight = (LineAABasics.line_subpixel_scale - x) * (LineAABasics.line_subpixel_scale - y); r += weight * ptr->m_R; g += weight * ptr->m_G; b += weight * ptr->m_B; a += weight * ptr->m_A; ++ptr; weight = x * (LineAABasics.line_subpixel_scale - y); r += weight * ptr->m_R; g += weight * ptr->m_G; b += weight * ptr->m_B; a += weight * ptr->m_A; ptr = (RGBA_Bytes *)buf.GetPixelPointer(x_lr, y_lr + 1); weight = (LineAABasics.line_subpixel_scale - x) * y; r += weight * ptr->m_R; g += weight * ptr->m_G; b += weight * ptr->m_B; a += weight * ptr->m_A; ++ptr; weight = x * y; r += weight * ptr->m_R; g += weight * ptr->m_G; b += weight * ptr->m_B; a += weight * ptr->m_A; p->m_R = (byte)(r >> LineAABasics.line_subpixel_shift * 2); p->m_G = (byte)(g >> LineAABasics.line_subpixel_shift * 2); p->m_B = (byte)(b >> LineAABasics.line_subpixel_shift * 2); p->m_A = (byte)(a >> LineAABasics.line_subpixel_shift * 2); }
public unsafe void PixelHighResolution(RasterBuffer buf, RGBA_Bytes* p, int x, int y) { int r, g, b, a; r = g = b = a = LineAABasics.line_subpixel_scale * LineAABasics.line_subpixel_scale / 2; int weight; int x_lr = x >> LineAABasics.line_subpixel_shift; int y_lr = y >> LineAABasics.line_subpixel_shift; x &= LineAABasics.line_subpixel_mask; y &= LineAABasics.line_subpixel_mask; RGBA_Bytes* ptr = (RGBA_Bytes*)buf.GetPixelPointer(x_lr, y_lr); weight = (LineAABasics.line_subpixel_scale - x) * (LineAABasics.line_subpixel_scale - y); r += weight * ptr->m_R; g += weight * ptr->m_G; b += weight * ptr->m_B; a += weight * ptr->m_A; ++ptr; weight = x * (LineAABasics.line_subpixel_scale - y); r += weight * ptr->m_R; g += weight * ptr->m_G; b += weight * ptr->m_B; a += weight * ptr->m_A; ptr = (RGBA_Bytes*)buf.GetPixelPointer(x_lr, y_lr + 1); weight = (LineAABasics.line_subpixel_scale - x) * y; r += weight * ptr->m_R; g += weight * ptr->m_G; b += weight * ptr->m_B; a += weight * ptr->m_A; ++ptr; weight = x * y; r += weight * ptr->m_R; g += weight * ptr->m_G; b += weight * ptr->m_B; a += weight * ptr->m_A; p->m_R = (byte)(r >> LineAABasics.line_subpixel_shift * 2); p->m_G = (byte)(g >> LineAABasics.line_subpixel_shift * 2); p->m_B = (byte)(b >> LineAABasics.line_subpixel_shift * 2); p->m_A = (byte)(a >> LineAABasics.line_subpixel_shift * 2); }
//------------------------------------------------------------------------ public override bool LoadImage(uint idx, string file) { if (idx < (uint)max_images_e.max_images) { int len = file.Length; if (len < 4 || !file.EndsWith(".BMP")) { file += ".bmp"; } RasterBuffer temp = new RasterBuffer(); bool goodLoad = m_specific.load_pmap(file, idx, temp); m_rbuf_img.Add(temp); return(goodLoad); } return(true); }
public alpha_mask2_application(PixelFormats format, ERenderOrigin RenderOrigin) : base(format, RenderOrigin) { m_alpha_mask_rbuf = new RasterBuffer(); #if USE_CLIPPING_ALPHA_MASK m_alpha_mask = new AlphaMaskByteClipped(m_alpha_mask_rbuf, 1, 0); #else m_alpha_mask = new AlphaMaskByteUnclipped(m_alpha_mask_rbuf, 1, 0); #endif m_num_cb = new UI.SliderWidget <T>(5, 5, 150, 12); m_slider_value = M.Zero <T>(); parse_lion(); AddChild(m_num_cb); m_num_cb.range(5, 100); m_num_cb.value(10); m_num_cb.label("N={0:F3}"); m_num_cb.SetTransform(MatrixFactory <T> .NewIdentity(VectorDimension.Two)); }
//-------------------------------------------------------------------- public unsafe override void Generate(RGBA_Bytes *span, int x, int y, uint len) { RasterBuffer SourceRenderingBuffer = base.Source().PixelFormat.GetRenderingBuffer(); ISpanInterpolator spanInterpolator = base.Interpolator; spanInterpolator.Begin(x + base.FilterDxDbl(), y + base.FilterDyDbl(), len); do { int x_hr; int y_hr; spanInterpolator.Coordinates(out x_hr, out y_hr); int x_lr = x_hr >> (int)image_subpixel_scale_e.Shift; int y_lr = y_hr >> (int)image_subpixel_scale_e.Shift; byte *fg_ptr = SourceRenderingBuffer.GetPixelPointer(y_lr) + (x_lr * 3); //byte* fg_ptr = spanInterpolator.span(x_lr, y_lr, 1); (*span).m_R = fg_ptr[OrderR]; (*span).m_G = fg_ptr[OrderG]; (*span).m_B = fg_ptr[OrderB]; (*span).m_A = 255; ++span; spanInterpolator.Next(); } while(--len != 0); }
//------------------------------------------------------------------------ public override bool Init(uint width, uint height, uint flags) { if (m_specific.m_sys_format == PlatformSupportAbstract.PixelFormats.Undefined) { return(false); } m_window_flags = flags; System.Drawing.Size clientSize = new System.Drawing.Size(); clientSize.Width = (int)width; clientSize.Height = (int)height; m_specific.ClientSize = clientSize; if ((m_window_flags & (uint)EWindowFlags.Risizeable) == 0) { m_specific.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; m_specific.MaximizeBox = false; } m_rbuf_window = new RasterBuffer(); m_specific.create_pmap(width, height, m_rbuf_window); m_initial_width = width; m_initial_height = height; m_specific.Show(); m_Bounds.Bottom = 0; m_Bounds.Left = 0; m_Bounds.Top = height; m_Bounds.Right = width; OnInitialize(); m_specific.m_WindowContentNeedsRedraw = true; return(true); }
public void CopyFrom(RasterBuffer src, RectInt rect_src_ptr, int dx, int dy) { RectInt rsrc = new RectInt(rect_src_ptr.X1, rect_src_ptr.Y1, rect_src_ptr.X2 + 1, rect_src_ptr.Y2 + 1); // Version with xdst, ydst (absolute positioning) //rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1); // Version with dx, dy (relative positioning) RectInt rdst = new RectInt(rsrc.X1 + dx, rsrc.Y1 + dy, rsrc.X2 + dx, rsrc.Y2 + dy); RectInt rc = ClipRectArea(ref rdst, ref rsrc, (int)src.Width, (int)src.Height); if (rc.X2 > 0) { int incy = 1; if (rdst.Y1 > rsrc.Y1) { rsrc.Y1 += rc.Y2 - 1; rdst.Y1 += rc.Y2 - 1; incy = -1; } while (rc.Y2 > 0) { base.CopyFrom(src, rdst.X1, rdst.Y1, rsrc.X1, rsrc.Y1, (uint)rc.X2); rdst.Y1 += incy; rsrc.Y1 += incy; --rc.Y2; } } }
public void CopyFrom(RasterBuffer src, RectI rect_src_ptr, int dx, int dy) { RectI rsrc = new RectI(rect_src_ptr.x1, rect_src_ptr.y1, rect_src_ptr.x2 + 1, rect_src_ptr.y2 + 1); // Version with xdst, ydst (absolute positioning) //RectI rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1); // Version with dx, dy (relative positioning) RectI rdst = new RectI(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy); RectI rc = ClipRectangleArea(ref rdst, ref rsrc, (int)src.Width(), (int)src.Height()); if (rc.x2 > 0) { int incy = 1; if (rdst.y1 > rsrc.y1) { rsrc.y1 += rc.y2 - 1; rdst.y1 += rc.y2 - 1; incy = -1; } while (rc.y2 > 0) { base.CopyFrom(src, rdst.x1, rdst.y1, rsrc.x1, rsrc.y1, (uint)rc.x2); rdst.y1 += incy; rsrc.y1 += incy; --rc.y2; } } }
public void CopyFrom(RasterBuffer sourceBuffer, int xdst, int ydst, int xsrc, int ysrc, uint len) { unsafe { Basics.memmove(&m_rbuf.GetPixelPointer(ydst)[xdst * 4], &sourceBuffer.GetPixelPointer(ysrc)[xsrc * 4], (int)len * 4); } }
public FormatRGBA(RasterBuffer rb, IBlender blender) { m_rbuf = rb; Blender = blender; }
public virtual void CopyFrom(RasterBuffer from, int xdst, int ydst, int xsrc, int ysrc, uint len) { PixelFormat.CopyFrom(from, xdst, ydst, xsrc, ysrc, len); }
public void Attach(RasterBuffer rbuf) { m_rbuf = rbuf; }
///<summary> ///</summary> ///<param name="rb"></param> ///<param name="blender"></param> ///<param name="gammaTable"></param> public FormatRGB(RasterBuffer rb, IBlender blender, GammaLookupTable gammaTable) { _rasterBuffer = rb; Blender = blender; }
//------------------------------------------------------------------------ public override bool Init(uint width, uint height, uint flags) { if (m_specific.m_sys_format == PlatformSupportAbstract.PixelFormats.Undefined) { return false; } m_window_flags = flags; System.Drawing.Size clientSize = new System.Drawing.Size(); clientSize.Width = (int)width; clientSize.Height = (int)height; m_specific.ClientSize = clientSize; if ((m_window_flags & (uint)EWindowFlags.Risizeable) == 0) { m_specific.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; m_specific.MaximizeBox = false; } m_rbuf_window = new RasterBuffer(); m_specific.create_pmap(width, height, m_rbuf_window); m_initial_width = width; m_initial_height = height; m_specific.Show(); m_Bounds.Bottom = 0; m_Bounds.Left = 0; m_Bounds.Top = height; m_Bounds.Right = width; OnInitialize(); m_specific.m_WindowContentNeedsRedraw = true; return true; }
public void Attach(RasterBuffer rb) { _rasterBuffer = rb; }
public void Attach(RasterBuffer rbuf) { m_rbuf = rbuf; }
///<summary> ///</summary> ///<param name="rb"></param> ///<param name="blender"></param> public FormatRGB(RasterBuffer rb, IBlender blender) { _rasterBuffer = rb; Blender = blender; }
///<summary> ///</summary> ///<param name="rb"></param> ///<param name="blender"></param> ///<param name="gammaTable"></param> public FormatRGB(RasterBuffer rb, IBlender blender, GammaLookupTable gammaTable) { _rasterBuffer = rb; Blender = blender; }
unsafe private void BlendInFilterPixel(uint *fg, ref uint src_alpha, uint back_r, uint back_g, uint back_b, uint back_a, RasterBuffer SourceRenderingBuffer, int maxx, int maxy, int x_lr, int y_lr, uint weight) { byte *fg_ptr; unchecked { if ((uint)x_lr <= (uint)maxx && (uint)y_lr <= (uint)maxy) { fg_ptr = SourceRenderingBuffer.GetPixelPointer(y_lr) + x_lr * 3; fg[0] += weight * fg_ptr[0]; fg[1] += weight * fg_ptr[1]; fg[2] += weight * fg_ptr[2]; src_alpha += weight * BaseMask; } else { fg[OrderR] += back_r * weight; fg[OrderG] += back_g * weight; fg[OrderB] += back_b * weight; src_alpha += back_a * weight; } } }
// Create //-------------------------------------------------------------------- public void create(RasterBuffer src) { m_height = (int)agg_basics.uceil(src.Height()); m_width = (int)agg_basics.uceil(src.Width()); m_width_hr = (int)agg_basics.uround(src.Width() * LineAABasics.line_subpixel_scale); m_half_height_hr = (int)agg_basics.uround(src.Height() * LineAABasics.line_subpixel_scale / 2); m_offset_y_hr = m_dilation_hr + m_half_height_hr - LineAABasics.line_subpixel_scale / 2; m_half_height_hr += LineAABasics.line_subpixel_scale / 2; int NewSizeInBytes = (m_width + m_dilation * 2) * (m_height + m_dilation * 2); if (m_DataSizeInBytes < NewSizeInBytes) { if (m_data != null) { System.Runtime.InteropServices.Marshal.FreeHGlobal(m_data); } m_DataSizeInBytes = NewSizeInBytes; m_data = System.Runtime.InteropServices.Marshal.AllocHGlobal(m_DataSizeInBytes); } unsafe { m_buf.attach((byte*)m_data, (uint)(m_width + m_dilation * 2), (uint)(m_height + m_dilation * 2), (int)(m_width + m_dilation * 2), 32); int x, y; RGBA_Bytes* d1; RGBA_Bytes* d2; for (y = 0; y < m_height; y++) { d1 = (RGBA_Bytes*)m_buf.GetPixelPointer(y + m_dilation) + m_dilation; for (x = 0; x < m_width; x++) { *d1++ = *(RGBA_Bytes*)src.GetPixelPointer(x, y); } } RGBA_Bytes* s1; RGBA_Bytes* s2; RGBA_Bytes noColor = (RGBA_Bytes)RGBA_Bytes.no_color(); for (y = 0; y < m_dilation; y++) { //s1 = m_buf.GetPixelPointer(m_height + m_dilation - 1) + m_dilation; //s2 = m_buf.GetPixelPointer(m_dilation) + m_dilation; d1 = (RGBA_Bytes*)m_buf.GetPixelPointer(m_dilation + m_height + y) + m_dilation; d2 = (RGBA_Bytes*)m_buf.GetPixelPointer(m_dilation - y - 1) + m_dilation; for (x = 0; x < m_width; x++) { //*d1++ = RGBA_Bytes(*s1++, 0); //*d2++ = RGBA_Bytes(*s2++, 0); *d1++ = noColor; *d2++ = noColor; } } int h = m_height + m_dilation * 2; for (y = 0; y < h; y++) { s1 = (RGBA_Bytes*)m_buf.GetPixelPointer(y) + m_dilation; s2 = (RGBA_Bytes*)m_buf.GetPixelPointer(y) + m_dilation + m_width; d1 = (RGBA_Bytes*)m_buf.GetPixelPointer(y) + m_dilation + m_width; d2 = (RGBA_Bytes*)m_buf.GetPixelPointer(y) + m_dilation; for (x = 0; x < m_dilation; x++) { *d1++ = *s1++; *--d2 = *--s2; } } } }
// Create //-------------------------------------------------------------------- public line_image_pattern(IPatternFilter filter, RasterBuffer src) { m_filter=(filter); m_dilation=(filter.dilation() + 1); m_dilation_hr=(m_dilation << LineAABasics.line_subpixel_shift); m_width=0; m_height=0; m_width_hr=0; m_half_height_hr=0; m_offset_y_hr=(0); m_buf = src; create(src); }
public void CopyFrom(RasterBuffer sourceBuffer, int xdst, int ydst, int xsrc, int ysrc, uint len) { unsafe { byte* pSource = sourceBuffer.GetPixelPointer(ysrc); if (pSource != null) { int BytesPerScanLine = Stride; Basics.memmove(m_rbuf.GetPixelPointer(ydst) + xdst * BytesPerScanLine, pSource + xsrc * BytesPerScanLine, (int)len * BytesPerScanLine); } } }
public virtual void CopyFrom(RasterBuffer from, int xdst, int ydst, int xsrc, int ysrc, uint len) { m_pixf.CopyFrom(from, xdst, ydst, xsrc, ysrc, len); }
unsafe private void BlendInFilterPixel(uint *fg, uint back_r, uint back_g, uint back_b, uint back_a, RasterBuffer pSourceRenderingBuffer, int maxx, int maxy, int x_lr, int y_lr, uint weight) { unchecked { byte *fg_ptr; if ((uint)x_lr <= (uint)maxx && (uint)y_lr <= (uint)maxy) { fg_ptr = pSourceRenderingBuffer.GetPixelPointer(y_lr) + (x_lr << 2); fg[0] += weight * fg_ptr[0]; fg[1] += weight * fg_ptr[1]; fg[2] += weight * fg_ptr[2]; fg[3] += weight * fg_ptr[3]; } else { fg[OrderR] += back_r * weight; fg[OrderG] += back_g * weight; fg[OrderB] += back_b * weight; fg[OrderA] += back_a * weight; } } }
public override void CopyFrom(RasterBuffer from, int xdst, int ydst, int xsrc, int ysrc, uint len) { throw new System.NotImplementedException(); }
public void Attach(RasterBuffer rb) { _rasterBuffer = rb; }
///<summary> ///</summary> ///<param name="rbuf"></param> ///<param name="step"></param> ///<param name="offset"></param> public AlphaMaskByteUnclipped(RasterBuffer rbuf, uint step, uint offset) { _step = step; _offset = offset; _rasterBuffer = rbuf; }
//------------------------------------------------------------------------ public override bool LoadImage(uint idx, string file) { if (idx < (uint)max_images_e.max_images) { int len = file.Length; if (len < 4 || !file.EndsWith(".BMP")) { file += ".bmp"; } RasterBuffer temp = new RasterBuffer(); bool goodLoad = m_specific.load_pmap(file, idx, temp); m_rbuf_img.Add(temp); return goodLoad; } return true; }
// Create //-------------------------------------------------------------------- public void create(RasterBuffer src) { m_height = (int)agg_basics.uceil(src.Height()); m_width = (int)agg_basics.uceil(src.Width()); m_width_hr = (int)agg_basics.uround(src.Width() * LineAABasics.line_subpixel_scale); m_half_height_hr = (int)agg_basics.uround(src.Height() * LineAABasics.line_subpixel_scale / 2); m_offset_y_hr = m_dilation_hr + m_half_height_hr - LineAABasics.line_subpixel_scale / 2; m_half_height_hr += LineAABasics.line_subpixel_scale / 2; int NewSizeInBytes = (m_width + m_dilation * 2) * (m_height + m_dilation * 2); if (m_DataSizeInBytes < NewSizeInBytes) { if (m_data != null) { System.Runtime.InteropServices.Marshal.FreeHGlobal(m_data); } m_DataSizeInBytes = NewSizeInBytes; m_data = System.Runtime.InteropServices.Marshal.AllocHGlobal(m_DataSizeInBytes); } unsafe { m_buf.attach((byte *)m_data, (uint)(m_width + m_dilation * 2), (uint)(m_height + m_dilation * 2), (int)(m_width + m_dilation * 2), 32); int x, y; RGBA_Bytes *d1; RGBA_Bytes *d2; for (y = 0; y < m_height; y++) { d1 = (RGBA_Bytes *)m_buf.GetPixelPointer(y + m_dilation) + m_dilation; for (x = 0; x < m_width; x++) { *d1++ = *(RGBA_Bytes *)src.GetPixelPointer(x, y); } } RGBA_Bytes *s1; RGBA_Bytes *s2; RGBA_Bytes noColor = (RGBA_Bytes)RGBA_Bytes.no_color(); for (y = 0; y < m_dilation; y++) { //s1 = m_buf.GetPixelPointer(m_height + m_dilation - 1) + m_dilation; //s2 = m_buf.GetPixelPointer(m_dilation) + m_dilation; d1 = (RGBA_Bytes *)m_buf.GetPixelPointer(m_dilation + m_height + y) + m_dilation; d2 = (RGBA_Bytes *)m_buf.GetPixelPointer(m_dilation - y - 1) + m_dilation; for (x = 0; x < m_width; x++) { //*d1++ = RGBA_Bytes(*s1++, 0); //*d2++ = RGBA_Bytes(*s2++, 0); *d1++ = noColor; *d2++ = noColor; } } int h = m_height + m_dilation * 2; for (y = 0; y < h; y++) { s1 = (RGBA_Bytes *)m_buf.GetPixelPointer(y) + m_dilation; s2 = (RGBA_Bytes *)m_buf.GetPixelPointer(y) + m_dilation + m_width; d1 = (RGBA_Bytes *)m_buf.GetPixelPointer(y) + m_dilation + m_width; d2 = (RGBA_Bytes *)m_buf.GetPixelPointer(y) + m_dilation; for (x = 0; x < m_dilation; x++) { *d1++ = *s1++; *--d2 = *--s2; } } } }
public AlphaMaskByteUnclipped(RasterBuffer rbuf, uint Step, uint Offset) { m_Step = Step; m_Offset = Offset; m_rbuf = rbuf; }
public virtual void CopyFrom(RasterBuffer from, int xdst, int ydst, int xsrc, int ysrc, uint len) { PixelFormat.CopyFrom(from, xdst, ydst, xsrc, ysrc, len); }
public blur_application(PixelFormats format, ERenderOrigin RenderOrigin) : base(format, RenderOrigin) { m_rbuf2 = new RasterBuffer(); m_shape_bounds = new RectDouble <T>(); m_method = new rbox_ctrl <T>(10.0, 10.0, 130.0, 70.0); m_radius = new SliderWidget <T>(130 + 10.0, 10.0 + 4.0, 130 + 300.0, 10.0 + 8.0 + 4.0); m_shadow_ctrl = new polygon_ctrl <T>(4); m_channel_r = new cbox_ctrl <T>(10.0, 80.0, "Red"); m_channel_g = new cbox_ctrl <T>(10.0, 95.0, "Green"); m_channel_b = new cbox_ctrl <T>(10.0, 110.0, "Blue"); m_FlattenCurves = new cbox_ctrl <T>(10, 315, "Convert And Flatten Curves"); m_FlattenCurves.status(true); AddChild(m_method); m_method.text_size(8); m_method.add_item("Stack Blur"); m_method.add_item("Recursive Blur"); m_method.add_item("Channels"); m_method.cur_item(1); AddChild(m_radius); m_radius.range(0.0, 40.0); m_radius.value(15.0); m_radius.label("Blur Radius={0:F2}"); AddChild(m_shadow_ctrl); AddChild(m_channel_r); AddChild(m_channel_g); AddChild(m_channel_b); AddChild(m_FlattenCurves); m_channel_g.status(true); m_sl = new ScanlinePacked8(); m_path = new PathStorage <T>(); m_shape = new ConvCurve <T>(m_path); m_path.RemoveAll(); m_path.MoveTo(28.47, 6.45); m_path.Curve3(21.58, 1.12, 19.82, 0.29); m_path.Curve3(17.19, -0.93, 14.21, -0.93); m_path.Curve3(9.57, -0.93, 6.57, 2.25); m_path.Curve3(3.56, 5.42, 3.56, 10.60); m_path.Curve3(3.56, 13.87, 5.03, 16.26); m_path.Curve3(7.03, 19.58, 11.99, 22.51); m_path.Curve3(16.94, 25.44, 28.47, 29.64); m_path.LineTo(28.47, 31.40); m_path.Curve3(28.47, 38.09, 26.34, 40.58); m_path.Curve3(24.22, 43.07, 20.17, 43.07); m_path.Curve3(17.09, 43.07, 15.28, 41.41); m_path.Curve3(13.43, 39.75, 13.43, 37.60); m_path.LineTo(13.53, 34.77); m_path.Curve3(13.53, 32.52, 12.38, 31.30); m_path.Curve3(11.23, 30.08, 9.38, 30.08); m_path.Curve3(7.57, 30.08, 6.42, 31.35); m_path.Curve3(5.27, 32.62, 5.27, 34.81); m_path.Curve3(5.27, 39.01, 9.57, 42.53); m_path.Curve3(13.87, 46.04, 21.63, 46.04); m_path.Curve3(27.59, 46.04, 31.40, 44.04); m_path.Curve3(34.28, 42.53, 35.64, 39.31); m_path.Curve3(36.52, 37.21, 36.52, 30.71); m_path.LineTo(36.52, 15.53); m_path.Curve3(36.52, 9.13, 36.77, 7.69); m_path.Curve3(37.01, 6.25, 37.57, 5.76); m_path.Curve3(38.13, 5.27, 38.87, 5.27); m_path.Curve3(39.65, 5.27, 40.23, 5.62); m_path.Curve3(41.26, 6.25, 44.19, 9.18); m_path.LineTo(44.19, 6.45); m_path.Curve3(38.72, -0.88, 33.74, -0.88); m_path.Curve3(31.35, -0.88, 29.93, 0.78); m_path.Curve3(28.52, 2.44, 28.47, 6.45); m_path.ClosePolygon(); m_path.MoveTo(28.47, 9.62); m_path.LineTo(28.47, 26.66); m_path.Curve3(21.09, 23.73, 18.95, 22.51); m_path.Curve3(15.09, 20.36, 13.43, 18.02); m_path.Curve3(11.77, 15.67, 11.77, 12.89); m_path.Curve3(11.77, 9.38, 13.87, 7.06); m_path.Curve3(15.97, 4.74, 18.70, 4.74); m_path.Curve3(22.41, 4.74, 28.47, 9.62); m_path.ClosePolygon(); IAffineTransformMatrix <T> shape_mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two); shape_mtx.Scale(M.New <T>(4.0)); shape_mtx.Translate(MatrixFactory <T> .CreateVector2D(150, 100)); m_path.Transform(shape_mtx); BoundingRect <T> .BoundingRectSingle(m_shape, 0, ref m_shape_bounds); m_shadow_ctrl.SetXN(0, m_shape_bounds.x1); m_shadow_ctrl.SetYN(0, m_shape_bounds.y1); m_shadow_ctrl.SetXN(1, m_shape_bounds.x2); m_shadow_ctrl.SetYN(1, m_shape_bounds.y1); m_shadow_ctrl.SetXN(2, m_shape_bounds.x2); m_shadow_ctrl.SetYN(2, m_shape_bounds.y2); m_shadow_ctrl.SetXN(3, m_shape_bounds.x1); m_shadow_ctrl.SetYN(3, m_shape_bounds.y2); m_shadow_ctrl.line_color(new RGBA_Doubles(0, 0.3, 0.5, 0.3)); }
public unsafe void Generate(out RGBA_Bytes destPixel, int x, int y) { base.Interpolator.Begin(M.New <T>(x).Add(base.FilterDxDbl()), M.New <T>(y).Add(base.FilterDyDbl()), 1); uint *fg = stackalloc uint[4]; byte *fg_ptr; RasterBuffer pSourceRenderingBuffer = base.Source().PixelFormat.GetRenderingBuffer(); int maxx = (int)pSourceRenderingBuffer.Width - 1; int maxy = (int)pSourceRenderingBuffer.Height - 1; ISpanInterpolator <T> spanInterpolator = base.Interpolator; unchecked { int x_hr; int y_hr; spanInterpolator.Coordinates(out x_hr, out y_hr); x_hr -= base.FilterDxInt(); y_hr -= base.FilterDyInt(); int x_lr = x_hr >> (int)image_subpixel_scale_e.Shift; int y_lr = y_hr >> (int)image_subpixel_scale_e.Shift; uint weight; fg[0] = fg[1] = fg[2] = fg[3] = (int)image_subpixel_scale_e.Scale * (int)image_subpixel_scale_e.Scale / 2; x_hr &= (int)image_subpixel_scale_e.Mask; y_hr &= (int)image_subpixel_scale_e.Mask; fg_ptr = pSourceRenderingBuffer.GetPixelPointer(y_lr) + (x_lr << 2); weight = (uint)(((int)image_subpixel_scale_e.Scale - x_hr) * ((int)image_subpixel_scale_e.Scale - y_hr)); fg[0] += weight * fg_ptr[0]; fg[1] += weight * fg_ptr[1]; fg[2] += weight * fg_ptr[2]; fg[3] += weight * fg_ptr[3]; weight = (uint)(x_hr * ((int)image_subpixel_scale_e.Scale - y_hr)); fg[0] += weight * fg_ptr[4]; fg[1] += weight * fg_ptr[5]; fg[2] += weight * fg_ptr[6]; fg[3] += weight * fg_ptr[7]; ++y_lr; fg_ptr = pSourceRenderingBuffer.GetPixelPointer(y_lr) + (x_lr << 2); weight = (uint)(((int)image_subpixel_scale_e.Scale - x_hr) * y_hr); fg[0] += weight * fg_ptr[0]; fg[1] += weight * fg_ptr[1]; fg[2] += weight * fg_ptr[2]; fg[3] += weight * fg_ptr[3]; weight = (uint)(x_hr * y_hr); fg[0] += weight * fg_ptr[4]; fg[1] += weight * fg_ptr[5]; fg[2] += weight * fg_ptr[6]; fg[3] += weight * fg_ptr[7]; fg[0] >>= (int)image_subpixel_scale_e.Shift * 2; fg[1] >>= (int)image_subpixel_scale_e.Shift * 2; fg[2] >>= (int)image_subpixel_scale_e.Shift * 2; fg[3] >>= (int)image_subpixel_scale_e.Shift * 2; destPixel = new RGBA_Bytes((byte)fg[OrderR], (byte)fg[OrderG], (byte)fg[OrderB], (byte)fg[OrderA]); //destPixel.R = (byte)fg[OrderR]; //destPixel.G = (byte)fg[OrderG]; //destPixel.B = (byte)fg[OrderB]; //destPixel.A = (byte)fg[OrderA]; } }
//-------------------------------------------------------------------- public FormatRGBA(RasterBuffer rb, IBlender blender, GammaLookupTable gammaTable) : this(rb, blender) { throw new System.NotImplementedException("Not using the Gamma table yet."); }
public unsafe override void Generate(RGBA_Bytes *span, int x, int y, uint len) { #if use_timers Generate_Span.Start(); #endif base.Interpolator.Begin(M.New <T>(x).Add(base.FilterDxDbl()), M.New <T>(y).Add(base.FilterDyDbl()), len); uint *fg = stackalloc uint[4]; byte *fg_ptr; RasterBuffer pSourceRenderingBuffer = base.Source().PixelFormat.GetRenderingBuffer(); int maxx = (int)pSourceRenderingBuffer.Width - 1; int maxy = (int)pSourceRenderingBuffer.Height - 1; ISpanInterpolator <T> spanInterpolator = base.Interpolator; unchecked { do { int x_hr; int y_hr; spanInterpolator.Coordinates(out x_hr, out y_hr); x_hr -= base.FilterDxInt(); y_hr -= base.FilterDyInt(); int x_lr = x_hr >> (int)image_subpixel_scale_e.Shift; int y_lr = y_hr >> (int)image_subpixel_scale_e.Shift; uint weight; fg[0] = fg[1] = fg[2] = fg[3] = (int)image_subpixel_scale_e.Scale * (int)image_subpixel_scale_e.Scale / 2; x_hr &= (int)image_subpixel_scale_e.Mask; y_hr &= (int)image_subpixel_scale_e.Mask; fg_ptr = pSourceRenderingBuffer.GetPixelPointer(y_lr) + (x_lr << 2); weight = (uint)(((int)image_subpixel_scale_e.Scale - x_hr) * ((int)image_subpixel_scale_e.Scale - y_hr)); fg[0] += weight * fg_ptr[0]; fg[1] += weight * fg_ptr[1]; fg[2] += weight * fg_ptr[2]; fg[3] += weight * fg_ptr[3]; weight = (uint)(x_hr * ((int)image_subpixel_scale_e.Scale - y_hr)); fg[0] += weight * fg_ptr[4]; fg[1] += weight * fg_ptr[5]; fg[2] += weight * fg_ptr[6]; fg[3] += weight * fg_ptr[7]; ++y_lr; fg_ptr = pSourceRenderingBuffer.GetPixelPointer(y_lr) + (x_lr << 2); weight = (uint)(((int)image_subpixel_scale_e.Scale - x_hr) * y_hr); fg[0] += weight * fg_ptr[0]; fg[1] += weight * fg_ptr[1]; fg[2] += weight * fg_ptr[2]; fg[3] += weight * fg_ptr[3]; weight = (uint)(x_hr * y_hr); fg[0] += weight * fg_ptr[4]; fg[1] += weight * fg_ptr[5]; fg[2] += weight * fg_ptr[6]; fg[3] += weight * fg_ptr[7]; fg[0] >>= (int)image_subpixel_scale_e.Shift * 2; fg[1] >>= (int)image_subpixel_scale_e.Shift * 2; fg[2] >>= (int)image_subpixel_scale_e.Shift * 2; fg[3] >>= (int)image_subpixel_scale_e.Shift * 2; //(*span).R = (byte)fg[OrderR]; //(*span).G = (byte)fg[OrderG]; //(*span).B = (byte)fg[OrderB]; //(*span).A = (byte)fg[OrderA]; (*span) = new RGBA_Bytes((byte)fg[OrderR], (byte)fg[OrderG], (byte)fg[OrderB], (byte)fg[OrderA]); ++span; spanInterpolator.Next(); } while (--len != 0); } #if use_timers Generate_Span.Stop(); #endif }
public void attach(RasterBuffer rb) { m_rbuf = rb; }
public unsafe override void Generate(RGBA_Bytes *span, int x, int y, uint len) { #if use_timers Generate_Span.Start(); #endif base.Interpolator.Begin(M.New <T>(x).Add(base.FilterDxDbl()), M.New <T>(y).Add(base.FilterDyDbl()), len); //uint[] fg = new uint[4]; uint *fg = stackalloc uint[4]; uint back_r = m_back_color.R; uint back_g = m_back_color.G; uint back_b = m_back_color.B; uint back_a = m_back_color.A; byte *fg_ptr; RasterBuffer pSourceRenderingBuffer = base.Source().PixelFormat.GetRenderingBuffer(); int maxx = (int)pSourceRenderingBuffer.Width - 1; int maxy = (int)pSourceRenderingBuffer.Height - 1; ISpanInterpolator <T> spanInterpolator = base.Interpolator; unchecked { do { int x_hr; int y_hr; spanInterpolator.Coordinates(out x_hr, out y_hr); x_hr -= base.FilterDxInt(); y_hr -= base.FilterDyInt(); int x_lr = x_hr >> (int)image_subpixel_scale_e.Shift; int y_lr = y_hr >> (int)image_subpixel_scale_e.Shift; uint weight; if (x_lr >= 0 && y_lr >= 0 && x_lr < maxx && y_lr < maxy) { fg[0] = fg[1] = fg[2] = fg[3] = (int)image_subpixel_scale_e.Scale * (int)image_subpixel_scale_e.Scale / 2; x_hr &= (int)image_subpixel_scale_e.Mask; y_hr &= (int)image_subpixel_scale_e.Mask; fg_ptr = pSourceRenderingBuffer.GetPixelPointer(y_lr) + (x_lr << 2); weight = (uint)(((int)image_subpixel_scale_e.Scale - x_hr) * ((int)image_subpixel_scale_e.Scale - y_hr)); fg[0] += weight * fg_ptr[0]; fg[1] += weight * fg_ptr[1]; fg[2] += weight * fg_ptr[2]; fg[3] += weight * fg_ptr[3]; weight = (uint)(x_hr * ((int)image_subpixel_scale_e.Scale - y_hr)); fg[0] += weight * fg_ptr[4]; fg[1] += weight * fg_ptr[5]; fg[2] += weight * fg_ptr[6]; fg[3] += weight * fg_ptr[7]; ++y_lr; fg_ptr = pSourceRenderingBuffer.GetPixelPointer(y_lr) + (x_lr << 2); weight = (uint)(((int)image_subpixel_scale_e.Scale - x_hr) * y_hr); fg[0] += weight * fg_ptr[0]; fg[1] += weight * fg_ptr[1]; fg[2] += weight * fg_ptr[2]; fg[3] += weight * fg_ptr[3]; weight = (uint)(x_hr * y_hr); fg[0] += weight * fg_ptr[4]; fg[1] += weight * fg_ptr[5]; fg[2] += weight * fg_ptr[6]; fg[3] += weight * fg_ptr[7]; fg[0] >>= (int)image_subpixel_scale_e.Shift * 2; fg[1] >>= (int)image_subpixel_scale_e.Shift * 2; fg[2] >>= (int)image_subpixel_scale_e.Shift * 2; fg[3] >>= (int)image_subpixel_scale_e.Shift * 2; } else { if (x_lr < -1 || y_lr < -1 || x_lr > maxx || y_lr > maxy) { fg[OrderR] = back_r; fg[OrderG] = back_g; fg[OrderB] = back_b; fg[OrderA] = back_a; } else { fg[0] = fg[1] = fg[2] = fg[3] = (int)image_subpixel_scale_e.Scale * (int)image_subpixel_scale_e.Scale / 2; x_hr &= (int)image_subpixel_scale_e.Mask; y_hr &= (int)image_subpixel_scale_e.Mask; weight = (uint)(((int)image_subpixel_scale_e.Scale - x_hr) * ((int)image_subpixel_scale_e.Scale - y_hr)); BlendInFilterPixel(fg, back_r, back_g, back_b, back_a, pSourceRenderingBuffer, maxx, maxy, x_lr, y_lr, weight); x_lr++; weight = (uint)(x_hr * ((int)image_subpixel_scale_e.Scale - y_hr)); BlendInFilterPixel(fg, back_r, back_g, back_b, back_a, pSourceRenderingBuffer, maxx, maxy, x_lr, y_lr, weight); x_lr--; y_lr++; weight = (uint)(((int)image_subpixel_scale_e.Scale - x_hr) * y_hr); BlendInFilterPixel(fg, back_r, back_g, back_b, back_a, pSourceRenderingBuffer, maxx, maxy, x_lr, y_lr, weight); x_lr++; weight = (uint)(x_hr * y_hr); BlendInFilterPixel(fg, back_r, back_g, back_b, back_a, pSourceRenderingBuffer, maxx, maxy, x_lr, y_lr, weight); fg[0] >>= (int)image_subpixel_scale_e.Shift * 2; fg[1] >>= (int)image_subpixel_scale_e.Shift * 2; fg[2] >>= (int)image_subpixel_scale_e.Shift * 2; fg[3] >>= (int)image_subpixel_scale_e.Shift * 2; } } //(*span).R = (byte)fg[0]; //(*span).G = (byte)fg[1]; //(*span).B = (byte)fg[2]; //(*span).A = (byte)fg[3]; (*span) = new RGBA_Bytes((byte)fg[0], (byte)fg[1], (byte)fg[2], (byte)fg[3]); ++span; spanInterpolator.Next(); } while (--len != 0); } #if use_timers Generate_Span.Stop(); #endif }
public AlphaMaskByteUnclipped(RasterBuffer rbuf, uint Step, uint Offset) { m_Step = Step; m_Offset = Offset; m_rbuf = rbuf; }
//-------------------------------------------------------------------- //-------------------------------------------------------------------- public FormatGray(RasterBuffer rb, IBlenderGray blender, uint step, uint offset) { m_rbuf = rb; Blender = blender; m_Step = step; m_Offset = offset; }
public unsafe void create_pmap(uint width, uint height, RasterBuffer wnd) { m_pmap_window = new PixelMap(); m_pmap_window.Create(width, height, PlatformSupportAbstract.GetBitDepthForPixelFormat(m_format)); wnd.Attach(m_pmap_window.buf(), m_pmap_window.Width(), m_pmap_window.Height(), m_RenderOrigin == PlatformSupportAbstract.ERenderOrigin.OriginBottomLeft ? -m_pmap_window.stride() : m_pmap_window.stride(), m_pmap_window.bpp()); }
public FormatRGB(RasterBuffer rb, IBlender blender, GammaLut gammaTable) { m_rbuf = rb; Blender = blender; }
public void attach(RasterBuffer rb) { m_rbuf = rb; }
public void display_pmap(Graphics displayGraphics, RasterBuffer src) { if (m_sys_format == m_format) { m_pmap_window.Draw(displayGraphics); } else { PixelMap pmap_tmp = new PixelMap(); pmap_tmp.Create(m_pmap_window.Width(), m_pmap_window.Height(), PlatformSupportAbstract.GetBitDepthForPixelFormat(m_sys_format)); RasterBuffer rbuf_tmp = new RasterBuffer(); unsafe { rbuf_tmp.Attach(pmap_tmp.buf(), pmap_tmp.Width(), pmap_tmp.Height(), m_app.FlipY() ? pmap_tmp.stride() : -pmap_tmp.stride(), pmap_tmp.bpp()); } convert_pmap(rbuf_tmp, src, m_format); pmap_tmp.Draw(displayGraphics); throw new System.NotImplementedException(); } }
public void CopyFrom(RasterBuffer src) { CopyFrom(src, new RectI(0, 0, (int)src.Width(), (int)src.Height()), 0, 0); }
public bool load_pmap(string fn, uint idx, RasterBuffer dst) { PixelMap pmap_tmp = new PixelMap(); if (!pmap_tmp.load_from_bmp(fn)) return false; RasterBuffer rbuf_tmp = new RasterBuffer(); unsafe { rbuf_tmp.Attach(pmap_tmp.buf(), pmap_tmp.Width(), pmap_tmp.Height(), m_app.FlipY() ? pmap_tmp.stride() : -pmap_tmp.stride(), pmap_tmp.bpp()); m_pmap_img[idx] = new PixelMap(); m_pmap_img[idx].Create(pmap_tmp.Width(), pmap_tmp.Height(), PlatformSupportAbstract.GetBitDepthForPixelFormat(m_format), 0); dst.Attach(m_pmap_img[idx].buf(), m_pmap_img[idx].Width(), m_pmap_img[idx].Height(), m_app.FlipY() ? m_pmap_img[idx].stride() : -m_pmap_img[idx].stride(), m_pmap_img[idx].bpp()); switch (m_format) { case PlatformSupportAbstract.PixelFormats.Bgr24: switch (pmap_tmp.bpp()) { case 24: unsafe { for (uint y = 0; y < rbuf_tmp.Height(); y++) { byte* sourceBuffer = rbuf_tmp.GetPixelPointer((int)rbuf_tmp.Height() - (int)y - 1); byte* destBuffer = dst.GetPixelPointer((int)y); for (uint x = 0; x < rbuf_tmp.Width(); x++) { *destBuffer++ = sourceBuffer[0]; *destBuffer++ = sourceBuffer[1]; *destBuffer++ = sourceBuffer[2]; sourceBuffer += 3; } } } break; default: throw new System.NotImplementedException(); } break; case PlatformSupportAbstract.PixelFormats.Rgb24: switch (pmap_tmp.bpp()) { // case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgb24()); break; case 24: //color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgba32()); unsafe { for (uint y = 0; y < rbuf_tmp.Height(); y++) { byte* sourceBuffer = rbuf_tmp.GetPixelPointer((int)rbuf_tmp.Height() - (int)y - 1); byte* destBuffer = dst.GetPixelPointer((int)y); for (uint x = 0; x < rbuf_tmp.Width(); x++) { *destBuffer++ = sourceBuffer[2]; *destBuffer++ = sourceBuffer[1]; *destBuffer++ = sourceBuffer[0]; sourceBuffer += 3; } } } break; // case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_rgb24()); break; default: throw new System.NotImplementedException(); } break; case PlatformSupportAbstract.PixelFormats.Bgra32: switch (pmap_tmp.bpp()) { case 24: unsafe { for (uint y = 0; y < rbuf_tmp.Height(); y++) { byte* sourceBuffer = rbuf_tmp.GetPixelPointer((int)rbuf_tmp.Height() - (int)y - 1); byte* destBuffer = dst.GetPixelPointer((int)y); for (uint x = 0; x < rbuf_tmp.Width(); x++) { *destBuffer++ = sourceBuffer[0]; *destBuffer++ = sourceBuffer[1]; *destBuffer++ = sourceBuffer[2]; *destBuffer++ = 255; sourceBuffer += 3; } } } break; } break; case PlatformSupportAbstract.PixelFormats.Rgba32: switch (pmap_tmp.bpp()) { // case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgba32()); break; case 24: //color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgba32()); unsafe { for (uint y = 0; y < rbuf_tmp.Height(); y++) { byte* sourceBuffer = rbuf_tmp.GetPixelPointer((int)rbuf_tmp.Height() - (int)y - 1); byte* destBuffer = dst.GetPixelPointer((int)y); for (uint x = 0; x < rbuf_tmp.Width(); x++) { *destBuffer++ = sourceBuffer[2]; *destBuffer++ = sourceBuffer[1]; *destBuffer++ = sourceBuffer[0]; *destBuffer++ = 255; sourceBuffer += 3; } } } break; // case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_rgba32()); break; default: throw new System.NotImplementedException(); } break; default: throw new System.NotImplementedException(); } } return true; }
public void CopyFrom(RasterBuffer src, RectI rect_src_ptr, int dx, int dy) { RectI rsrc = new RectI(rect_src_ptr.x1, rect_src_ptr.y1, rect_src_ptr.x2 + 1, rect_src_ptr.y2 + 1); // Version with xdst, ydst (absolute positioning) //RectI rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1); // Version with dx, dy (relative positioning) RectI rdst = new RectI(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy); RectI rc = ClipRectangleArea(ref rdst, ref rsrc, (int)src.Width(), (int)src.Height()); if (rc.x2 > 0) { int incy = 1; if (rdst.y1 > rsrc.y1) { rsrc.y1 += rc.y2 - 1; rdst.y1 += rc.y2 - 1; incy = -1; } while (rc.y2 > 0) { base.CopyFrom(src, rdst.x1, rdst.y1, rsrc.x1, rsrc.y1, (uint)rc.x2); rdst.y1 += incy; rsrc.y1 += incy; --rc.y2; } } }
public bool save_pmap(string fn, uint idx, RasterBuffer src) { return true; }
///<summary> ///</summary> ///<param name="rbuf"></param> public void Attach(RasterBuffer rbuf) { _rasterBuffer = rbuf; }
private static void convert_pmap(RasterBuffer dst, RasterBuffer src, PlatformSupportAbstract.PixelFormats format) { }