skia-bindings 0.97.0

Skia Bindings for Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

#include "bindings.h"

#include "include/gpu/ganesh/GrBackendSurface.h"
#include "include/gpu/ganesh/GrBackendSemaphore.h"
#include "include/gpu/ganesh/GrDirectContext.h"
#include "include/gpu/ganesh/d3d/GrD3DBackendContext.h"
#include "include/gpu/ganesh/d3d/GrD3DBackendSemaphore.h"
#include "include/gpu/ganesh/d3d/GrD3DBackendSurface.h"
#include "include/gpu/ganesh/d3d/GrD3DDirectContext.h"

// Additional types not yet referenced.
extern "C" void C_GrD3DTypes(GrD3DSurfaceInfo *) {};

//
// gpu/d3d/GrD3DTypes.h
//

extern "C" void C_GrD3DTextureResourceInfo_Construct(GrD3DTextureResourceInfo* uninitialized) {
    new(uninitialized) GrD3DTextureResourceInfo();
}

extern "C" void C_GrD3DFenceInfo_Construct(GrD3DFenceInfo* uninitialized) {
    new(uninitialized) GrD3DFenceInfo();
}

//
// gpu/d3d/GrD3DBackendSemaphore.h
//

extern "C" void C_GrBackendSemaphore_ConstructD3D(
    GrBackendSemaphore* uninitialized,
    const GrD3DFenceInfo* info) {
    new(uninitialized) GrBackendSemaphore(GrBackendSemaphores::MakeD3D(*info));
}

extern "C" void C_GrBackendSemaphores_GetD3DFenceInfo(
    const GrBackendSemaphore* semaphore,
    GrD3DFenceInfo* info) {
    *info = GrBackendSemaphores::GetD3DFenceInfo(*semaphore);
}

//
// gpu/GrBackendSurface.h
//

extern "C" void C_GrBackendFormat_ConstructD3D(GrBackendFormat* uninitialized, DXGI_FORMAT format) {
    new(uninitialized)GrBackendFormat(GrBackendFormats::MakeD3D(format));
}

extern "C" bool C_GrBackendFormats_AsDxgiFormat(const GrBackendFormat* format, DXGI_FORMAT* dxgiFormat) {
    const auto result = GrBackendFormats::AsDxgiFormat(*format);
    if (result == DXGI_FORMAT_UNKNOWN) {
        return false;
    }
    *dxgiFormat = result;
    return true;
}

extern "C" GrBackendTexture* C_GrBackendTexture_newD3D(
    int width, int height,
    const GrD3DTextureResourceInfo* resourceInfo, 
    const char* label,
    size_t labelCount) {
    return new GrBackendTexture(
            GrBackendTextures::MakeD3D(width, height, *resourceInfo, std::string_view(label, labelCount)));
}

extern "C" bool C_GrBackendTextures_GetD3DTextureResourceInfo(
        const GrBackendTexture* texture,
        GrD3DTextureResourceInfo* info) {
    auto result = GrBackendTextures::GetD3DTextureResourceInfo(*texture);
    if (result.fResource.get() == nullptr) {
        return false;
    }
    *info = result;
    return true;
}

extern "C" void C_GrBackendTextures_SetD3DResourceState(
        GrBackendTexture* texture,
        GrD3DResourceStateEnum state) {
    GrBackendTextures::SetD3DResourceState(texture, state);
}

extern "C" void C_GrBackendRenderTarget_ConstructD3D(GrBackendRenderTarget* uninitialized, int width, int height, const GrD3DTextureResourceInfo* resourceInfo) {
    new(uninitialized)GrBackendRenderTarget(GrBackendRenderTargets::MakeD3D(width, height, *resourceInfo));
}

extern "C" bool C_GrBackendRenderTargets_GetD3DTextureResourceInfo(
        const GrBackendRenderTarget* renderTarget,
        GrD3DTextureResourceInfo* info) {
    auto result = GrBackendRenderTargets::GetD3DTextureResourceInfo(*renderTarget);
    if (result.fResource.get() == nullptr) {
        return false;
    }
    *info = result;
    return true;
}

extern "C" void C_GrBackendRenderTargets_SetD3DResourceState(
        GrBackendRenderTarget* renderTarget,
        GrD3DResourceStateEnum state) {
    GrBackendRenderTargets::SetD3DResourceState(renderTarget, state);
}

//
// gpu/GrDirectContext.h
//

extern "C" GrDirectContext* C_GrDirectContexts_MakeD3D(
    const GrD3DBackendContext* backendContext,
    const GrContextOptions* options) {
    if (options) {
        return GrDirectContexts::MakeD3D(*backendContext, *options).release();
    }
    return GrDirectContexts::MakeD3D(*backendContext).release();
}

extern "C" GrDirectContext* C_GrDirectContext_MakeD3D(
    const GrD3DBackendContext* backendContext,
    const GrContextOptions* options) {
    return C_GrDirectContexts_MakeD3D(backendContext, options);
}