Struct skia_bindings::SkSurface

#[repr(C)]
pub struct SkSurface {
    pub _base: SkRefCnt,
    pub fProps: SkSurfaceProps,
    pub fWidth: c_int,
    pub fHeight: c_int,
    pub fGenerationID: u32,
}

Fields

_base: SkRefCnt

fProps: SkSurfaceProps

fWidth: c_int

fHeight: c_int

fGenerationID: u32

Methods

impl SkSurface

pub unsafe fn MakeRasterDirect(
    imageInfo: *const SkImageInfo,
    pixels: *mut c_void,
    rowBytes: usize,
    surfaceProps: *const SkSurfaceProps
) -> sk_sp<SkSurface>

pub unsafe fn MakeRasterDirectReleaseProc(
    imageInfo: *const SkImageInfo,
    pixels: *mut c_void,
    rowBytes: usize,
    releaseProc: Option<unsafe extern "C" fn(pixels: *mut c_void, context: *mut c_void)>,
    context: *mut c_void,
    surfaceProps: *const SkSurfaceProps
) -> sk_sp<SkSurface>

pub unsafe fn MakeRaster(
    imageInfo: *const SkImageInfo,
    rowBytes: usize,
    surfaceProps: *const SkSurfaceProps
) -> sk_sp<SkSurface>

pub unsafe fn MakeRaster1(
    imageInfo: *const SkImageInfo,
    props: *const SkSurfaceProps
) -> sk_sp<SkSurface>

pub unsafe fn MakeRasterN32Premul(
    width: c_int,
    height: c_int,
    surfaceProps: *const SkSurfaceProps
) -> sk_sp<SkSurface>

pub unsafe fn MakeFromBackendTexture(
    context: *mut GrContext,
    backendTexture: *const GrBackendTexture,
    origin: GrSurfaceOrigin,
    sampleCnt: c_int,
    colorType: SkColorType,
    colorSpace: sk_sp<SkColorSpace>,
    surfaceProps: *const SkSurfaceProps,
    textureReleaseProc: SkSurface_TextureReleaseProc,
    releaseContext: SkSurface_ReleaseContext
) -> sk_sp<SkSurface>

pub unsafe fn MakeFromBackendRenderTarget(
    context: *mut GrContext,
    backendRenderTarget: *const GrBackendRenderTarget,
    origin: GrSurfaceOrigin,
    colorType: SkColorType,
    colorSpace: sk_sp<SkColorSpace>,
    surfaceProps: *const SkSurfaceProps,
    releaseProc: SkSurface_RenderTargetReleaseProc,
    releaseContext: SkSurface_ReleaseContext
) -> sk_sp<SkSurface>

pub unsafe fn MakeFromBackendTextureAsRenderTarget(
    context: *mut GrContext,
    backendTexture: *const GrBackendTexture,
    origin: GrSurfaceOrigin,
    sampleCnt: c_int,
    colorType: SkColorType,
    colorSpace: sk_sp<SkColorSpace>,
    surfaceProps: *const SkSurfaceProps
) -> sk_sp<SkSurface>

pub unsafe fn MakeRenderTarget(
    context: *mut GrContext,
    budgeted: SkBudgeted,
    imageInfo: *const SkImageInfo,
    sampleCount: c_int,
    surfaceOrigin: GrSurfaceOrigin,
    surfaceProps: *const SkSurfaceProps,
    shouldCreateWithMips: bool
) -> sk_sp<SkSurface>

pub unsafe fn MakeRenderTarget1(
    context: *mut GrContext,
    budgeted: SkBudgeted,
    imageInfo: *const SkImageInfo,
    sampleCount: c_int,
    props: *const SkSurfaceProps
) -> sk_sp<SkSurface>

pub unsafe fn MakeRenderTarget2(
    context: *mut GrContext,
    budgeted: SkBudgeted,
    imageInfo: *const SkImageInfo
) -> sk_sp<SkSurface>

pub unsafe fn MakeRenderTarget3(
    context: *mut GrRecordingContext,
    characterization: *const SkSurfaceCharacterization,
    budgeted: SkBudgeted
) -> sk_sp<SkSurface>

pub unsafe fn MakeNull(width: c_int, height: c_int) -> sk_sp<SkSurface>

pub unsafe fn width(&self) -> c_int

pub unsafe fn height(&self) -> c_int

pub unsafe fn generationID(&mut self) -> u32

pub unsafe fn notifyContentWillChange(
    &mut self,
    mode: SkSurface_ContentChangeMode
)

pub unsafe fn getBackendTexture(
    &mut self,
    backendHandleAccess: SkSurface_BackendHandleAccess
) -> GrBackendTexture

pub unsafe fn getBackendRenderTarget(
    &mut self,
    backendHandleAccess: SkSurface_BackendHandleAccess
) -> GrBackendRenderTarget

pub unsafe fn replaceBackendTexture(
    &mut self,
    backendTexture: *const GrBackendTexture,
    origin: GrSurfaceOrigin,
    textureReleaseProc: SkSurface_TextureReleaseProc,
    releaseContext: SkSurface_ReleaseContext
) -> bool

pub unsafe fn getCanvas(&mut self) -> *mut SkCanvas

pub unsafe fn makeSurface(
    &mut self,
    imageInfo: *const SkImageInfo
) -> sk_sp<SkSurface>

pub unsafe fn makeImageSnapshot(&mut self) -> sk_sp<SkImage>

pub unsafe fn makeImageSnapshot1(
    &mut self,
    bounds: *const SkIRect
) -> sk_sp<SkImage>

pub unsafe fn draw(
    &mut self,
    canvas: *mut SkCanvas,
    x: SkScalar,
    y: SkScalar,
    paint: *const SkPaint
)

pub unsafe fn peekPixels(&mut self, pixmap: *mut SkPixmap) -> bool

pub unsafe fn readPixels(
    &mut self,
    dst: *const SkPixmap,
    srcX: c_int,
    srcY: c_int
) -> bool

pub unsafe fn readPixels1(
    &mut self,
    dstInfo: *const SkImageInfo,
    dstPixels: *mut c_void,
    dstRowBytes: usize,
    srcX: c_int,
    srcY: c_int
) -> bool

pub unsafe fn readPixels2(
    &mut self,
    dst: *const SkBitmap,
    srcX: c_int,
    srcY: c_int
) -> bool

pub unsafe fn asyncRescaleAndReadPixels(
    &mut self,
    info: *const SkImageInfo,
    srcRect: *const SkIRect,
    rescaleGamma: SkSurface_RescaleGamma,
    rescaleQuality: SkFilterQuality,
    callback: SkSurface_ReadPixelsCallback,
    context: SkSurface_ReadPixelsContext
)

pub unsafe fn writePixels(
    &mut self,
    src: *const SkPixmap,
    dstX: c_int,
    dstY: c_int
)

pub unsafe fn writePixels1(
    &mut self,
    src: *const SkBitmap,
    dstX: c_int,
    dstY: c_int
)

pub unsafe fn props(&self) -> *const SkSurfaceProps

pub unsafe fn flush(&mut self)

pub unsafe fn flush1(
    &mut self,
    access: SkSurface_BackendSurfaceAccess,
    info: *const GrFlushInfo
) -> GrSemaphoresSubmitted

pub unsafe fn flush2(
    &mut self,
    access: SkSurface_BackendSurfaceAccess,
    flags: GrFlushFlags,
    numSemaphores: c_int,
    signalSemaphores: *mut GrBackendSemaphore,
    finishedProc: GrGpuFinishedProc,
    finishedContext: GrGpuFinishedContext
) -> GrSemaphoresSubmitted

pub unsafe fn flush3(
    &mut self,
    access: SkSurface_BackendSurfaceAccess,
    flags: SkSurface_FlushFlags,
    numSemaphores: c_int,
    signalSemaphores: *mut GrBackendSemaphore
) -> GrSemaphoresSubmitted

pub unsafe fn flushAndSignalSemaphores(
    &mut self,
    numSemaphores: c_int,
    signalSemaphores: *mut GrBackendSemaphore
) -> GrSemaphoresSubmitted

pub unsafe fn wait(
    &mut self,
    numSemaphores: c_int,
    waitSemaphores: *const GrBackendSemaphore
) -> bool

pub unsafe fn characterize(
    &self,
    characterization: *mut SkSurfaceCharacterization
) -> bool

pub unsafe fn draw1(
    &mut self,
    deferredDisplayList: *mut SkDeferredDisplayList
) -> bool

pub unsafe fn dirtyGenerationID(&mut self)

pub unsafe fn new(
    width: c_int,
    height: c_int,
    surfaceProps: *const SkSurfaceProps
) -> Self

pub unsafe fn new1(
    imageInfo: *const SkImageInfo,
    surfaceProps: *const SkSurfaceProps
) -> Self

Trait Implementations

impl Debug for SkSurface

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.