1 module bindbc.blend2d.bindstatic; 2 3 version(BindBC_Static) version = BindBlend2D_Static; 4 5 import core.stdc.stdint; 6 import core.stdc.stdarg; 7 8 auto BL_MAJOR_VERSION(uint ver) { return ver >> 16; } 9 auto BL_MINOR_VERSION(uint ver) { return (ver >> 8) & ((1 << 8) - 1); } 10 auto BL_PATCH_VERSION(uint ver) { return ver & ((1 << 8) - 1); } 11 12 enum BLEND2D_VERSION_MAJOR = BL_MAJOR_VERSION(BL_VERSION); 13 enum BLEND2D_VERSION_MINOR = BL_MINOR_VERSION(BL_VERSION); 14 enum BLEND2D_VERSION_REVISION = BL_PATCH_VERSION(BL_VERSION); 15 16 private 17 enum expandEnum(EnumType, string fqnEnumType = EnumType.stringof) = (){ 18 string expandEnum = "enum {"; 19 foreach(m;__traits(allMembers, EnumType)) { 20 expandEnum ~= m ~ " = " ~ fqnEnumType ~ "." ~ m ~ ","; 21 } 22 expandEnum ~= "}"; 23 return expandEnum; 24 }(); 25 26 27 mixin(expandEnum!BLResultCode); 28 mixin(expandEnum!BLByteOrder); 29 mixin(expandEnum!BLDataAccessFlags); 30 mixin(expandEnum!BLDataSourceType); 31 mixin(expandEnum!BLModifyOp); 32 mixin(expandEnum!BLBooleanOp); 33 mixin(expandEnum!BLExtendMode); 34 mixin(expandEnum!BLTextEncoding); 35 mixin(expandEnum!BLContextType); 36 mixin(expandEnum!BLContextHint); 37 mixin(expandEnum!BLContextOpType); 38 mixin(expandEnum!BLContextFlushFlags); 39 mixin(expandEnum!BLContextCreateFlags); 40 mixin(expandEnum!BLContextProperty); 41 mixin(expandEnum!BLContextErrorFlags); 42 mixin(expandEnum!BLClipMode); 43 mixin(expandEnum!BLCompOp); 44 mixin(expandEnum!BLGradientQuality); 45 mixin(expandEnum!BLPatternQuality); 46 mixin(expandEnum!BLRenderingQuality); 47 mixin(expandEnum!BLFileOpenFlags); 48 mixin(expandEnum!BLFileSeekType); 49 mixin(expandEnum!BLFileReadFlags); 50 mixin(expandEnum!BLGlyphPlacementType); 51 mixin(expandEnum!BLGlyphRunFlags); 52 mixin(expandEnum!BLFontDataFlags); 53 mixin(expandEnum!BLFontFaceType); 54 mixin(expandEnum!BLFontFaceFlags); 55 mixin(expandEnum!BLFontFaceDiagFlags); 56 mixin(expandEnum!BLFontOutlineType); 57 mixin(expandEnum!BLFontStretch); 58 mixin(expandEnum!BLFontStyle); 59 mixin(expandEnum!BLFontWeight); 60 mixin(expandEnum!BLFontStringId); 61 mixin(expandEnum!BLFontUnicodeCoverageIndex); 62 mixin(expandEnum!BLTextDirection); 63 mixin(expandEnum!BLTextOrientation); 64 mixin(expandEnum!BLFormat); 65 mixin(expandEnum!BLFormatFlags); 66 mixin(expandEnum!BLGeometryDirection); 67 mixin(expandEnum!BLGeometryType); 68 mixin(expandEnum!BLFillRule); 69 mixin(expandEnum!BLHitTest); 70 mixin(expandEnum!BLGradientType); 71 mixin(expandEnum!BLGradientValue); 72 mixin(expandEnum!BLImageInfoFlags); 73 mixin(expandEnum!BLImageScaleFilter); 74 mixin(expandEnum!BLImageCodecFeatures); 75 mixin(expandEnum!BLMatrix2DType); 76 mixin(expandEnum!BLMatrix2DValue); 77 mixin(expandEnum!BLMatrix2DOp); 78 mixin(expandEnum!BLPathCmd); 79 mixin(expandEnum!BLPathCmdExtra); 80 mixin(expandEnum!BLPathFlags); 81 mixin(expandEnum!BLPathReverseMode); 82 mixin(expandEnum!BLStrokeJoin); 83 mixin(expandEnum!BLStrokeCapPosition); 84 mixin(expandEnum!BLStrokeCap); 85 mixin(expandEnum!BLStrokeTransformOrder); 86 mixin(expandEnum!BLFlattenMode); 87 mixin(expandEnum!BLOffsetMode); 88 mixin(expandEnum!BLPixelConverterCreateFlags); 89 mixin(expandEnum!BLRegionType); 90 mixin(expandEnum!BLRuntimeLimits); 91 mixin(expandEnum!BLRuntimeInfoType); 92 mixin(expandEnum!BLRuntimeBuildType); 93 mixin(expandEnum!BLRuntimeCpuArch); 94 mixin(expandEnum!BLRuntimeCpuFeatures); 95 mixin(expandEnum!BLRuntimeCleanupFlags); 96 mixin(expandEnum!BLStyleType); 97 mixin(expandEnum!BLImplType); 98 mixin(expandEnum!BLImplTraits); 99 100 101 //****** api.d ******// 102 103 import core.stdc.stddef; 104 import core.stdc.stdint; 105 106 extern (C): 107 108 extern (D) auto BL_MAKE_VERSION(T0, T1, T2)(auto ref T0 MAJOR, auto ref T1 MINOR, auto ref T2 PATCH) 109 { 110 return (MAJOR << 16) | (MINOR << 8) | PATCH; 111 } 112 113 enum BL_VERSION = BL_MAKE_VERSION(0, 0, 1); 114 115 enum BL_BYTE_ORDER = 1234; 116 117 extern (D) auto BL_MAKE_TAG(T0, T1, T2, T3)(auto ref T0 A, auto ref T1 B, auto ref T2 C, auto ref T3 D) 118 { 119 return cast(BLTag) (cast(BLTag) A << 24) | (cast(BLTag) B << 16) | (cast(BLTag) C << 8) | (cast(BLTag) D); 120 } 121 122 //enum BL_DIAGNOSTIC_POP = _Pragma("clang diagnostic pop"); 123 //enum BL_DIAGNOSTIC_NO_INVALID_OFFSETOF = _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\""); 124 //enum BL_DIAGNOSTIC_NO_SHADOW = _Pragma("clang diagnostic ignored \"-Wshadow\""); 125 //enum BL_DIAGNOSTIC_NO_STRICT_ALIASING = _Pragma("clang diagnostic ignored \"-Wstrict-aliasing\""); 126 //enum BL_DIAGNOSTIC_NO_UNUSED_FUNCTIONS = _Pragma("clang diagnostic ignored \"-Wunused-function\""); 127 //enum BL_DIAGNOSTIC_NO_UNUSED_PARAMETERS = _Pragma("clang diagnostic ignored \"-Wunused-parameter\""); 128 //enum BL_DIAGNOSTIC_NO_EXTRA_WARNINGS = _Pragma("clang diagnostic ignored \"-Wextra\""); 129 130 //struct BLRandom; 131 //struct BLFileCore; 132 133 //struct BLRuntimeBuildInfo; 134 //struct BLRuntimeSystemInfo; 135 //struct BLRuntimeResourceInfo; 136 137 //struct BLStringCore; 138 //struct BLStringImpl; 139 140 //struct BLArrayCore; 141 //struct BLArrayImpl; 142 143 //struct BLVariantCore; 144 //struct BLVariantImpl; 145 146 //struct BLPointI; 147 //struct BLPoint; 148 //struct BLSizeI; 149 //struct BLSize; 150 //struct BLBoxI; 151 //struct BLBox; 152 //struct BLRectI; 153 //struct BLRect; 154 //struct BLLine; 155 //struct BLTriangle; 156 //struct BLRoundRect; 157 //struct BLCircle; 158 //struct BLEllipse; 159 //struct BLArc; 160 //struct BLMatrix2D; 161 //struct BLApproximationOptions; 162 //struct BLStrokeOptionsCore; 163 164 //struct BLPathCore; 165 //struct BLPathImpl; 166 //struct BLPathView; 167 168 //struct BLRegionCore; 169 //struct BLRegionImpl; 170 171 //struct BLFormatInfo; 172 //struct BLImageCore; 173 //struct BLImageImpl; 174 //struct BLImageData; 175 //struct BLImageInfo; 176 //struct BLImageScaleOptions; 177 178 //struct BLPixelConverterCore; 179 //struct BLPixelConverterOptions; 180 181 //struct BLImageCodecCore; 182 //struct BLImageCodecImpl; 183 //struct BLImageCodecVirt; 184 185 //struct BLImageDecoderCore; 186 //struct BLImageDecoderImpl; 187 //struct BLImageDecoderVirt; 188 189 //struct BLImageEncoderCore; 190 //struct BLImageEncoderImpl; 191 //struct BLImageEncoderVirt; 192 193 //struct BLRgba32; 194 //struct BLRgba64; 195 //struct BLRgba; 196 197 //struct BLGradientCore; 198 //struct BLGradientImpl; 199 //struct BLGradientStop; 200 201 //struct BLLinearGradientValues; 202 //struct BLRadialGradientValues; 203 //struct BLConicalGradientValues; 204 205 //struct BLPatternCore; 206 //struct BLPatternImpl; 207 208 //struct BLStyleCore; 209 210 //struct BLContextCore; 211 //struct BLContextImpl; 212 //struct BLContextVirt; 213 //struct BLContextCookie; 214 //struct BLContextCreateInfo; 215 //struct BLContextHints; 216 //struct BLContextState; 217 218 //struct BLGlyphBufferCore; 219 //struct BLGlyphBufferImpl; 220 //struct BLGlyphInfo; 221 //struct BLGlyphMappingState; 222 //struct BLGlyphOutlineSinkInfo; 223 //struct BLGlyphPlacement; 224 //struct BLGlyphRun; 225 226 //struct BLFontUnicodeCoverage; 227 //struct BLFontFaceInfo; 228 //struct BLFontQueryProperties; 229 //struct BLFontFeature; 230 //struct BLFontDesignMetrics; 231 //struct BLFontMatrix; 232 //struct BLFontMetrics; 233 //struct BLFontPanose; 234 //struct BLFontTable; 235 //struct BLFontVariation; 236 //struct BLTextMetrics; 237 238 //struct BLFontCore; 239 //struct BLFontImpl; 240 //struct BLFontVirt; 241 242 //struct BLFontFaceCore; 243 //struct BLFontFaceImpl; 244 //struct BLFontFaceVirt; 245 246 //struct BLFontDataCore; 247 //struct BLFontDataImpl; 248 //struct BLFontDataVirt; 249 250 //struct BLFontManagerCore; 251 //struct BLFontManagerImpl; 252 //struct BLFontManagerVirt; 253 254 alias BLResult = uint; 255 256 alias BLBitWord = ulong; 257 258 alias BLTag = uint; 259 260 alias BLUniqueId = ulong; 261 262 alias BLDestroyImplFunc = void function(void* impl, void* destroyData); 263 264 alias BLPathSinkFunc = uint function(BLPathCore* path, const(void)* info, void* closure); 265 266 enum BLResultCode 267 { 268 BL_SUCCESS = 0, 269 270 BL_ERROR_START_INDEX = 0x00010000u, 271 272 BL_ERROR_OUT_OF_MEMORY = 0x00010000u, 273 BL_ERROR_INVALID_VALUE = 65537, 274 BL_ERROR_INVALID_STATE = 65538, 275 BL_ERROR_INVALID_HANDLE = 65539, 276 BL_ERROR_VALUE_TOO_LARGE = 65540, 277 BL_ERROR_NOT_INITIALIZED = 65541, 278 BL_ERROR_NOT_IMPLEMENTED = 65542, 279 BL_ERROR_NOT_PERMITTED = 65543, 280 281 BL_ERROR_IO = 65544, 282 BL_ERROR_BUSY = 65545, 283 BL_ERROR_INTERRUPTED = 65546, 284 BL_ERROR_TRY_AGAIN = 65547, 285 BL_ERROR_TIMED_OUT = 65548, 286 BL_ERROR_BROKEN_PIPE = 65549, 287 BL_ERROR_INVALID_SEEK = 65550, 288 BL_ERROR_SYMLINK_LOOP = 65551, 289 BL_ERROR_FILE_TOO_LARGE = 65552, 290 BL_ERROR_ALREADY_EXISTS = 65553, 291 BL_ERROR_ACCESS_DENIED = 65554, 292 BL_ERROR_MEDIA_CHANGED = 65555, 293 BL_ERROR_READ_ONLY_FS = 65556, 294 BL_ERROR_NO_DEVICE = 65557, 295 BL_ERROR_NO_ENTRY = 65558, 296 BL_ERROR_NO_MEDIA = 65559, 297 BL_ERROR_NO_MORE_DATA = 65560, 298 BL_ERROR_NO_MORE_FILES = 65561, 299 BL_ERROR_NO_SPACE_LEFT = 65562, 300 BL_ERROR_NOT_EMPTY = 65563, 301 BL_ERROR_NOT_FILE = 65564, 302 BL_ERROR_NOT_DIRECTORY = 65565, 303 BL_ERROR_NOT_SAME_DEVICE = 65566, 304 BL_ERROR_NOT_BLOCK_DEVICE = 65567, 305 306 BL_ERROR_INVALID_FILE_NAME = 65568, 307 BL_ERROR_FILE_NAME_TOO_LONG = 65569, 308 309 BL_ERROR_TOO_MANY_OPEN_FILES = 65570, 310 BL_ERROR_TOO_MANY_OPEN_FILES_BY_OS = 65571, 311 BL_ERROR_TOO_MANY_LINKS = 65572, 312 BL_ERROR_TOO_MANY_THREADS = 65573, 313 BL_ERROR_THREAD_POOL_EXHAUSTED = 65574, 314 315 BL_ERROR_FILE_EMPTY = 65575, 316 BL_ERROR_OPEN_FAILED = 65576, 317 BL_ERROR_NOT_ROOT_DEVICE = 65577, 318 319 BL_ERROR_UNKNOWN_SYSTEM_ERROR = 65578, 320 321 BL_ERROR_INVALID_ALIGNMENT = 65579, 322 BL_ERROR_INVALID_SIGNATURE = 65580, 323 BL_ERROR_INVALID_DATA = 65581, 324 BL_ERROR_INVALID_STRING = 65582, 325 BL_ERROR_DATA_TRUNCATED = 65583, 326 BL_ERROR_DATA_TOO_LARGE = 65584, 327 BL_ERROR_DECOMPRESSION_FAILED = 65585, 328 329 BL_ERROR_INVALID_GEOMETRY = 65586, 330 BL_ERROR_NO_MATCHING_VERTEX = 65587, 331 332 BL_ERROR_NO_MATCHING_COOKIE = 65588, 333 BL_ERROR_NO_STATES_TO_RESTORE = 65589, 334 335 BL_ERROR_IMAGE_TOO_LARGE = 65590, 336 BL_ERROR_IMAGE_NO_MATCHING_CODEC = 65591, 337 BL_ERROR_IMAGE_UNKNOWN_FILE_FORMAT = 65592, 338 BL_ERROR_IMAGE_DECODER_NOT_PROVIDED = 65593, 339 BL_ERROR_IMAGE_ENCODER_NOT_PROVIDED = 65594, 340 341 BL_ERROR_PNG_MULTIPLE_IHDR = 65595, 342 BL_ERROR_PNG_INVALID_IDAT = 65596, 343 BL_ERROR_PNG_INVALID_IEND = 65597, 344 BL_ERROR_PNG_INVALID_PLTE = 65598, 345 BL_ERROR_PNG_INVALID_TRNS = 65599, 346 BL_ERROR_PNG_INVALID_FILTER = 65600, 347 348 BL_ERROR_JPEG_UNSUPPORTED_FEATURE = 65601, 349 BL_ERROR_JPEG_INVALID_SOS = 65602, 350 BL_ERROR_JPEG_INVALID_SOF = 65603, 351 BL_ERROR_JPEG_MULTIPLE_SOF = 65604, 352 BL_ERROR_JPEG_UNSUPPORTED_SOF = 65605, 353 354 BL_ERROR_FONT_NOT_INITIALIZED = 65606, 355 BL_ERROR_FONT_NO_MATCH = 65607, 356 BL_ERROR_FONT_NO_CHARACTER_MAPPING = 65608, 357 BL_ERROR_FONT_MISSING_IMPORTANT_TABLE = 65609, 358 BL_ERROR_FONT_FEATURE_NOT_AVAILABLE = 65610, 359 BL_ERROR_FONT_CFF_INVALID_DATA = 65611, 360 BL_ERROR_FONT_PROGRAM_TERMINATED = 65612, 361 362 BL_ERROR_INVALID_GLYPH = 65613 363 } 364 365 enum BLByteOrder 366 { 367 BL_BYTE_ORDER_LE = 0, 368 369 BL_BYTE_ORDER_BE = 1, 370 371 BL_BYTE_ORDER_NATIVE = BL_BYTE_ORDER == 1234 ? BL_BYTE_ORDER_LE : BL_BYTE_ORDER_BE, 372 373 BL_BYTE_ORDER_SWAPPED = BL_BYTE_ORDER == 1234 ? BL_BYTE_ORDER_BE : BL_BYTE_ORDER_LE 374 } 375 376 enum BLDataAccessFlags 377 { 378 BL_DATA_ACCESS_READ = 0x01u, 379 380 BL_DATA_ACCESS_WRITE = 0x02u, 381 382 BL_DATA_ACCESS_RW = 0x03u 383 } 384 385 enum BLDataSourceType 386 { 387 BL_DATA_SOURCE_TYPE_NONE = 0, 388 389 BL_DATA_SOURCE_TYPE_MEMORY = 1, 390 391 BL_DATA_SOURCE_TYPE_FILE = 2, 392 393 BL_DATA_SOURCE_TYPE_CUSTOM = 3, 394 395 BL_DATA_SOURCE_TYPE_COUNT = 4 396 } 397 398 enum BLModifyOp 399 { 400 BL_MODIFY_OP_ASSIGN_FIT = 0, 401 402 BL_MODIFY_OP_ASSIGN_GROW = 1, 403 404 BL_MODIFY_OP_APPEND_FIT = 2, 405 406 BL_MODIFY_OP_APPEND_GROW = 3, 407 408 BL_MODIFY_OP_COUNT = 4 409 } 410 411 enum BLBooleanOp 412 { 413 BL_BOOLEAN_OP_COPY = 0, 414 415 BL_BOOLEAN_OP_AND = 1, 416 417 BL_BOOLEAN_OP_OR = 2, 418 419 BL_BOOLEAN_OP_XOR = 3, 420 421 BL_BOOLEAN_OP_SUB = 4, 422 423 BL_BOOLEAN_OP_COUNT = 5 424 } 425 426 enum BLExtendMode 427 { 428 BL_EXTEND_MODE_PAD = 0, 429 430 BL_EXTEND_MODE_REPEAT = 1, 431 432 BL_EXTEND_MODE_REFLECT = 2, 433 434 BL_EXTEND_MODE_PAD_X_PAD_Y = 0, 435 436 BL_EXTEND_MODE_REPEAT_X_REPEAT_Y = 1, 437 438 BL_EXTEND_MODE_REFLECT_X_REFLECT_Y = 2, 439 440 BL_EXTEND_MODE_PAD_X_REPEAT_Y = 3, 441 442 BL_EXTEND_MODE_PAD_X_REFLECT_Y = 4, 443 444 BL_EXTEND_MODE_REPEAT_X_PAD_Y = 5, 445 446 BL_EXTEND_MODE_REPEAT_X_REFLECT_Y = 6, 447 448 BL_EXTEND_MODE_REFLECT_X_PAD_Y = 7, 449 450 BL_EXTEND_MODE_REFLECT_X_REPEAT_Y = 8, 451 452 BL_EXTEND_MODE_SIMPLE_COUNT = 3, 453 454 BL_EXTEND_MODE_COMPLEX_COUNT = 9 455 } 456 457 enum BLTextEncoding 458 { 459 BL_TEXT_ENCODING_UTF8 = 0, 460 461 BL_TEXT_ENCODING_UTF16 = 1, 462 463 BL_TEXT_ENCODING_UTF32 = 2, 464 465 BL_TEXT_ENCODING_LATIN1 = 3, 466 467 BL_TEXT_ENCODING_WCHAR = wchar_t.sizeof == 4 ? BL_TEXT_ENCODING_UTF32 : wchar_t.sizeof == 2 ? BL_TEXT_ENCODING_UTF16 : BL_TEXT_ENCODING_UTF8, 468 469 BL_TEXT_ENCODING_COUNT = 4 470 } 471 472 BLResult blTraceError(BLResult result); 473 474 struct BLRange 475 { 476 size_t start; 477 size_t end; 478 } 479 480 struct BLCreateForeignInfo 481 { 482 void* data; 483 size_t size; 484 BLDestroyImplFunc destroyFunc; 485 void* destroyData; 486 } 487 488 struct BLArrayView 489 { 490 const(void)* data; 491 size_t size; 492 } 493 494 struct BLStringView 495 { 496 const(char)* data; 497 size_t size; 498 } 499 500 struct BLRegionView 501 { 502 const(BLBoxI)* data; 503 size_t size; 504 } 505 506 alias BLDataView = BLArrayView; 507 508 version(BindBlend2D_Static) BLResult blArrayInit(BLArrayCore* self, uint arrayTypeId); 509 version(BindBlend2D_Static) BLResult blArrayDestroy(BLArrayCore* self); 510 version(BindBlend2D_Static) BLResult blArrayReset(BLArrayCore* self); 511 version(BindBlend2D_Static) BLResult blArrayCreateFromData(BLArrayCore* self, void* data, size_t size, size_t capacity, uint dataAccessFlags, BLDestroyImplFunc destroyFunc, void* destroyData); 512 version(BindBlend2D_Static) size_t blArrayGetSize(const(BLArrayCore)* self); 513 version(BindBlend2D_Static) size_t blArrayGetCapacity(const(BLArrayCore)* self); 514 version(BindBlend2D_Static) const(void)* blArrayGetData(const(BLArrayCore)* self); 515 version(BindBlend2D_Static) BLResult blArrayClear(BLArrayCore* self); 516 version(BindBlend2D_Static) BLResult blArrayShrink(BLArrayCore* self); 517 version(BindBlend2D_Static) BLResult blArrayReserve(BLArrayCore* self, size_t n); 518 version(BindBlend2D_Static) BLResult blArrayResize(BLArrayCore* self, size_t n, const(void)* fill); 519 version(BindBlend2D_Static) BLResult blArrayMakeMutable(BLArrayCore* self, void** dataOut); 520 version(BindBlend2D_Static) BLResult blArrayModifyOp(BLArrayCore* self, uint op, size_t n, void** dataOut); 521 version(BindBlend2D_Static) BLResult blArrayInsertOp(BLArrayCore* self, size_t index, size_t n, void** dataOut); 522 version(BindBlend2D_Static) BLResult blArrayAssignMove(BLArrayCore* self, BLArrayCore* other); 523 version(BindBlend2D_Static) BLResult blArrayAssignWeak(BLArrayCore* self, const(BLArrayCore)* other); 524 version(BindBlend2D_Static) BLResult blArrayAssignDeep(BLArrayCore* self, const(BLArrayCore)* other); 525 version(BindBlend2D_Static) BLResult blArrayAssignView(BLArrayCore* self, const(void)* items, size_t n); 526 version(BindBlend2D_Static) BLResult blArrayAppendU8(BLArrayCore* self, ubyte value); 527 version(BindBlend2D_Static) BLResult blArrayAppendU16(BLArrayCore* self, ushort value); 528 version(BindBlend2D_Static) BLResult blArrayAppendU32(BLArrayCore* self, uint value); 529 version(BindBlend2D_Static) BLResult blArrayAppendU64(BLArrayCore* self, ulong value); 530 version(BindBlend2D_Static) BLResult blArrayAppendF32(BLArrayCore* self, float value); 531 version(BindBlend2D_Static) BLResult blArrayAppendF64(BLArrayCore* self, double value); 532 version(BindBlend2D_Static) BLResult blArrayAppendItem(BLArrayCore* self, const(void)* item); 533 version(BindBlend2D_Static) BLResult blArrayAppendView(BLArrayCore* self, const(void)* items, size_t n); 534 version(BindBlend2D_Static) BLResult blArrayInsertU8(BLArrayCore* self, size_t index, ubyte value); 535 version(BindBlend2D_Static) BLResult blArrayInsertU16(BLArrayCore* self, size_t index, ushort value); 536 version(BindBlend2D_Static) BLResult blArrayInsertU32(BLArrayCore* self, size_t index, uint value); 537 version(BindBlend2D_Static) BLResult blArrayInsertU64(BLArrayCore* self, size_t index, ulong value); 538 version(BindBlend2D_Static) BLResult blArrayInsertF32(BLArrayCore* self, size_t index, float value); 539 version(BindBlend2D_Static) BLResult blArrayInsertF64(BLArrayCore* self, size_t index, double value); 540 version(BindBlend2D_Static) BLResult blArrayInsertItem(BLArrayCore* self, size_t index, const(void)* item); 541 version(BindBlend2D_Static) BLResult blArrayInsertView(BLArrayCore* self, size_t index, const(void)* items, size_t n); 542 version(BindBlend2D_Static) BLResult blArrayReplaceU8(BLArrayCore* self, size_t index, ubyte value); 543 version(BindBlend2D_Static) BLResult blArrayReplaceU16(BLArrayCore* self, size_t index, ushort value); 544 version(BindBlend2D_Static) BLResult blArrayReplaceU32(BLArrayCore* self, size_t index, uint value); 545 version(BindBlend2D_Static) BLResult blArrayReplaceU64(BLArrayCore* self, size_t index, ulong value); 546 version(BindBlend2D_Static) BLResult blArrayReplaceF32(BLArrayCore* self, size_t index, float value); 547 version(BindBlend2D_Static) BLResult blArrayReplaceF64(BLArrayCore* self, size_t index, double value); 548 version(BindBlend2D_Static) BLResult blArrayReplaceItem(BLArrayCore* self, size_t index, const(void)* item); 549 version(BindBlend2D_Static) BLResult blArrayReplaceView(BLArrayCore* self, size_t rStart, size_t rEnd, const(void)* items, size_t n); 550 version(BindBlend2D_Static) BLResult blArrayRemoveIndex(BLArrayCore* self, size_t index); 551 version(BindBlend2D_Static) BLResult blArrayRemoveRange(BLArrayCore* self, size_t rStart, size_t rEnd); 552 version(BindBlend2D_Static) bool blArrayEquals(const(BLArrayCore)* a, const(BLArrayCore)* b); 553 554 version(BindBlend2D_Static) BLResult blContextInit(BLContextCore* self); 555 version(BindBlend2D_Static) BLResult blContextInitAs(BLContextCore* self, BLImageCore* image, const(BLContextCreateInfo)* options); 556 version(BindBlend2D_Static) BLResult blContextDestroy(BLContextCore* self); 557 version(BindBlend2D_Static) BLResult blContextReset(BLContextCore* self); 558 version(BindBlend2D_Static) BLResult blContextAssignMove(BLContextCore* self, BLContextCore* other); 559 version(BindBlend2D_Static) BLResult blContextAssignWeak(BLContextCore* self, const(BLContextCore)* other); 560 version(BindBlend2D_Static) uint blContextGetType(const(BLContextCore)* self); 561 version(BindBlend2D_Static) BLResult blContextGetTargetSize(const(BLContextCore)* self, BLSize* targetSizeOut); 562 version(BindBlend2D_Static) BLImageCore* blContextGetTargetImage(const(BLContextCore)* self); 563 version(BindBlend2D_Static) BLResult blContextBegin(BLContextCore* self, BLImageCore* image, const(BLContextCreateInfo)* options); 564 version(BindBlend2D_Static) BLResult blContextEnd(BLContextCore* self); 565 version(BindBlend2D_Static) BLResult blContextFlush(BLContextCore* self, uint flags); 566 version(BindBlend2D_Static) BLResult blContextQueryProperty(const(BLContextCore)* self, uint propertyId, void* valueOut); 567 version(BindBlend2D_Static) BLResult blContextSave(BLContextCore* self, BLContextCookie* cookie); 568 version(BindBlend2D_Static) BLResult blContextRestore(BLContextCore* self, const(BLContextCookie)* cookie); 569 version(BindBlend2D_Static) BLResult blContextGetMetaMatrix(const(BLContextCore)* self, BLMatrix2D* m); 570 version(BindBlend2D_Static) BLResult blContextGetUserMatrix(const(BLContextCore)* self, BLMatrix2D* m); 571 version(BindBlend2D_Static) BLResult blContextUserToMeta(BLContextCore* self); 572 version(BindBlend2D_Static) BLResult blContextMatrixOp(BLContextCore* self, uint opType, const(void)* opData); 573 version(BindBlend2D_Static) BLResult blContextSetHint(BLContextCore* self, uint hintType, uint value); 574 version(BindBlend2D_Static) BLResult blContextSetHints(BLContextCore* self, const(BLContextHints)* hints); 575 version(BindBlend2D_Static) BLResult blContextSetFlattenMode(BLContextCore* self, uint mode); 576 version(BindBlend2D_Static) BLResult blContextSetFlattenTolerance(BLContextCore* self, double tolerance); 577 version(BindBlend2D_Static) BLResult blContextSetApproximationOptions(BLContextCore* self, const(BLApproximationOptions)* options); 578 version(BindBlend2D_Static) BLResult blContextSetCompOp(BLContextCore* self, uint compOp); 579 version(BindBlend2D_Static) BLResult blContextSetGlobalAlpha(BLContextCore* self, double alpha); 580 version(BindBlend2D_Static) BLResult blContextSetFillAlpha(BLContextCore* self, double alpha); 581 version(BindBlend2D_Static) BLResult blContextGetFillStyle(const(BLContextCore)* self, BLStyleCore* styleOut); 582 version(BindBlend2D_Static) BLResult blContextSetFillStyle(BLContextCore* self, const(BLStyleCore)* style); 583 version(BindBlend2D_Static) BLResult blContextSetFillStyleRgba(BLContextCore* self, const(BLRgba)* rgba); 584 version(BindBlend2D_Static) BLResult blContextSetFillStyleRgba32(BLContextCore* self, uint rgba32); 585 version(BindBlend2D_Static) BLResult blContextSetFillStyleRgba64(BLContextCore* self, ulong rgba64); 586 version(BindBlend2D_Static) BLResult blContextSetFillStyleObject(BLContextCore* self, const(void)* object); 587 version(BindBlend2D_Static) BLResult blContextSetFillRule(BLContextCore* self, uint fillRule); 588 version(BindBlend2D_Static) BLResult blContextSetStrokeAlpha(BLContextCore* self, double alpha); 589 version(BindBlend2D_Static) BLResult blContextGetStrokeStyle(const(BLContextCore)* self, BLStyleCore* styleOut); 590 version(BindBlend2D_Static) BLResult blContextSetStrokeStyle(BLContextCore* self, const(BLStyleCore)* style); 591 version(BindBlend2D_Static) BLResult blContextSetStrokeStyleRgba(BLContextCore* self, const(BLRgba)* rgba); 592 version(BindBlend2D_Static) BLResult blContextSetStrokeStyleRgba32(BLContextCore* self, uint rgba32); 593 version(BindBlend2D_Static) BLResult blContextSetStrokeStyleRgba64(BLContextCore* self, ulong rgba64); 594 version(BindBlend2D_Static) BLResult blContextSetStrokeStyleObject(BLContextCore* self, const(void)* object); 595 version(BindBlend2D_Static) BLResult blContextSetStrokeWidth(BLContextCore* self, double width); 596 version(BindBlend2D_Static) BLResult blContextSetStrokeMiterLimit(BLContextCore* self, double miterLimit); 597 version(BindBlend2D_Static) BLResult blContextSetStrokeCap(BLContextCore* self, uint position, uint strokeCap); 598 version(BindBlend2D_Static) BLResult blContextSetStrokeCaps(BLContextCore* self, uint strokeCap); 599 version(BindBlend2D_Static) BLResult blContextSetStrokeJoin(BLContextCore* self, uint strokeJoin); 600 version(BindBlend2D_Static) BLResult blContextSetStrokeDashOffset(BLContextCore* self, double dashOffset); 601 version(BindBlend2D_Static) BLResult blContextSetStrokeDashArray(BLContextCore* self, const(BLArrayCore)* dashArray); 602 version(BindBlend2D_Static) BLResult blContextSetStrokeTransformOrder(BLContextCore* self, uint transformOrder); 603 version(BindBlend2D_Static) BLResult blContextGetStrokeOptions(const(BLContextCore)* self, BLStrokeOptionsCore* options); 604 version(BindBlend2D_Static) BLResult blContextSetStrokeOptions(BLContextCore* self, const(BLStrokeOptionsCore)* options); 605 version(BindBlend2D_Static) BLResult blContextClipToRectI(BLContextCore* self, const(BLRectI)* rect); 606 version(BindBlend2D_Static) BLResult blContextClipToRectD(BLContextCore* self, const(BLRect)* rect); 607 version(BindBlend2D_Static) BLResult blContextRestoreClipping(BLContextCore* self); 608 version(BindBlend2D_Static) BLResult blContextClearAll(BLContextCore* self); 609 version(BindBlend2D_Static) BLResult blContextClearRectI(BLContextCore* self, const(BLRectI)* rect); 610 version(BindBlend2D_Static) BLResult blContextClearRectD(BLContextCore* self, const(BLRect)* rect); 611 version(BindBlend2D_Static) BLResult blContextFillAll(BLContextCore* self); 612 version(BindBlend2D_Static) BLResult blContextFillRectI(BLContextCore* self, const(BLRectI)* rect); 613 version(BindBlend2D_Static) BLResult blContextFillRectD(BLContextCore* self, const(BLRect)* rect); 614 version(BindBlend2D_Static) BLResult blContextFillPathD(BLContextCore* self, const(BLPathCore)* path); 615 version(BindBlend2D_Static) BLResult blContextFillGeometry(BLContextCore* self, uint geometryType, const(void)* geometryData); 616 version(BindBlend2D_Static) BLResult blContextFillTextI(BLContextCore* self, const(BLPointI)* pt, const(BLFontCore)* font, const(void)* text, size_t size, uint encoding); 617 version(BindBlend2D_Static) BLResult blContextFillTextD(BLContextCore* self, const(BLPoint)* pt, const(BLFontCore)* font, const(void)* text, size_t size, uint encoding); 618 version(BindBlend2D_Static) BLResult blContextFillGlyphRunI(BLContextCore* self, const(BLPointI)* pt, const(BLFontCore)* font, const(BLGlyphRun)* glyphRun); 619 version(BindBlend2D_Static) BLResult blContextFillGlyphRunD(BLContextCore* self, const(BLPoint)* pt, const(BLFontCore)* font, const(BLGlyphRun)* glyphRun); 620 version(BindBlend2D_Static) BLResult blContextStrokeRectI(BLContextCore* self, const(BLRectI)* rect); 621 version(BindBlend2D_Static) BLResult blContextStrokeRectD(BLContextCore* self, const(BLRect)* rect); 622 version(BindBlend2D_Static) BLResult blContextStrokePathD(BLContextCore* self, const(BLPathCore)* path); 623 version(BindBlend2D_Static) BLResult blContextStrokeGeometry(BLContextCore* self, uint geometryType, const(void)* geometryData); 624 version(BindBlend2D_Static) BLResult blContextStrokeTextI(BLContextCore* self, const(BLPointI)* pt, const(BLFontCore)* font, const(void)* text, size_t size, uint encoding); 625 version(BindBlend2D_Static) BLResult blContextStrokeTextD(BLContextCore* self, const(BLPoint)* pt, const(BLFontCore)* font, const(void)* text, size_t size, uint encoding); 626 version(BindBlend2D_Static) BLResult blContextStrokeGlyphRunI(BLContextCore* self, const(BLPointI)* pt, const(BLFontCore)* font, const(BLGlyphRun)* glyphRun); 627 version(BindBlend2D_Static) BLResult blContextStrokeGlyphRunD(BLContextCore* self, const(BLPoint)* pt, const(BLFontCore)* font, const(BLGlyphRun)* glyphRun); 628 version(BindBlend2D_Static) BLResult blContextBlitImageI(BLContextCore* self, const(BLPointI)* pt, const(BLImageCore)* img, const(BLRectI)* imgArea); 629 version(BindBlend2D_Static) BLResult blContextBlitImageD(BLContextCore* self, const(BLPoint)* pt, const(BLImageCore)* img, const(BLRectI)* imgArea); 630 version(BindBlend2D_Static) BLResult blContextBlitScaledImageI(BLContextCore* self, const(BLRectI)* rect, const(BLImageCore)* img, const(BLRectI)* imgArea); 631 version(BindBlend2D_Static) BLResult blContextBlitScaledImageD(BLContextCore* self, const(BLRect)* rect, const(BLImageCore)* img, const(BLRectI)* imgArea); 632 633 version(BindBlend2D_Static) BLResult blFileInit(BLFileCore* self); 634 version(BindBlend2D_Static) BLResult blFileReset(BLFileCore* self); 635 version(BindBlend2D_Static) BLResult blFileOpen(BLFileCore* self, const(char)* fileName, uint openFlags); 636 version(BindBlend2D_Static) BLResult blFileClose(BLFileCore* self); 637 version(BindBlend2D_Static) BLResult blFileSeek(BLFileCore* self, long offset, uint seekType, long* positionOut); 638 version(BindBlend2D_Static) BLResult blFileRead(BLFileCore* self, void* buffer, size_t n, size_t* bytesReadOut); 639 version(BindBlend2D_Static) BLResult blFileWrite(BLFileCore* self, const(void)* buffer, size_t n, size_t* bytesWrittenOut); 640 version(BindBlend2D_Static) BLResult blFileTruncate(BLFileCore* self, long maxSize); 641 version(BindBlend2D_Static) BLResult blFileGetSize(BLFileCore* self, ulong* fileSizeOut); 642 643 version(BindBlend2D_Static) BLResult blFileSystemReadFile(const(char)* fileName, BLArrayCore* dst, size_t maxSize, uint readFlags); 644 version(BindBlend2D_Static) BLResult blFileSystemWriteFile(const(char)* fileName, const(void)* data, size_t size, size_t* bytesWrittenOut); 645 646 version(BindBlend2D_Static) BLResult blFontInit(BLFontCore* self); 647 version(BindBlend2D_Static) BLResult blFontDestroy(BLFontCore* self); 648 version(BindBlend2D_Static) BLResult blFontReset(BLFontCore* self); 649 version(BindBlend2D_Static) BLResult blFontAssignMove(BLFontCore* self, BLFontCore* other); 650 version(BindBlend2D_Static) BLResult blFontAssignWeak(BLFontCore* self, const(BLFontCore)* other); 651 version(BindBlend2D_Static) bool blFontEquals(const(BLFontCore)* a, const(BLFontCore)* b); 652 version(BindBlend2D_Static) BLResult blFontCreateFromFace(BLFontCore* self, const(BLFontFaceCore)* face, float size); 653 version(BindBlend2D_Static) BLResult blFontShape(const(BLFontCore)* self, BLGlyphBufferCore* gb); 654 version(BindBlend2D_Static) BLResult blFontMapTextToGlyphs(const(BLFontCore)* self, BLGlyphBufferCore* gb, BLGlyphMappingState* stateOut); 655 version(BindBlend2D_Static) BLResult blFontPositionGlyphs(const(BLFontCore)* self, BLGlyphBufferCore* gb, uint positioningFlags); 656 version(BindBlend2D_Static) BLResult blFontApplyKerning(const(BLFontCore)* self, BLGlyphBufferCore* gb); 657 version(BindBlend2D_Static) BLResult blFontApplyGSub(const(BLFontCore)* self, BLGlyphBufferCore* gb, size_t index, BLBitWord lookups); 658 version(BindBlend2D_Static) BLResult blFontApplyGPos(const(BLFontCore)* self, BLGlyphBufferCore* gb, size_t index, BLBitWord lookups); 659 version(BindBlend2D_Static) BLResult blFontGetMatrix(const(BLFontCore)* self, BLFontMatrix* out_); 660 version(BindBlend2D_Static) BLResult blFontGetMetrics(const(BLFontCore)* self, BLFontMetrics* out_); 661 version(BindBlend2D_Static) BLResult blFontGetDesignMetrics(const(BLFontCore)* self, BLFontDesignMetrics* out_); 662 version(BindBlend2D_Static) BLResult blFontGetTextMetrics(const(BLFontCore)* self, BLGlyphBufferCore* gb, BLTextMetrics* out_); 663 version(BindBlend2D_Static) BLResult blFontGetGlyphBounds(const(BLFontCore)* self, const(uint)* glyphData, intptr_t glyphAdvance, BLBoxI* out_, size_t count); 664 version(BindBlend2D_Static) BLResult blFontGetGlyphAdvances(const(BLFontCore)* self, const(uint)* glyphData, intptr_t glyphAdvance, BLGlyphPlacement* out_, size_t count); 665 version(BindBlend2D_Static) BLResult blFontGetGlyphOutlines(const(BLFontCore)* self, uint glyphId, const(BLMatrix2D)* userMatrix, BLPathCore* out_, BLPathSinkFunc sink, void* closure); 666 version(BindBlend2D_Static) BLResult blFontGetGlyphRunOutlines(const(BLFontCore)* self, const(BLGlyphRun)* glyphRun, const(BLMatrix2D)* userMatrix, BLPathCore* out_, BLPathSinkFunc sink, void* closure); 667 668 version(BindBlend2D_Static) BLResult blFontDataInit(BLFontDataCore* self); 669 version(BindBlend2D_Static) BLResult blFontDataDestroy(BLFontDataCore* self); 670 version(BindBlend2D_Static) BLResult blFontDataReset(BLFontDataCore* self); 671 version(BindBlend2D_Static) BLResult blFontDataAssignMove(BLFontDataCore* self, BLFontDataCore* other); 672 version(BindBlend2D_Static) BLResult blFontDataAssignWeak(BLFontDataCore* self, const(BLFontDataCore)* other); 673 version(BindBlend2D_Static) BLResult blFontDataCreateFromFile(BLFontDataCore* self, const(char)* fileName, uint readFlags); 674 version(BindBlend2D_Static) BLResult blFontDataCreateFromDataArray(BLFontDataCore* self, const(BLArrayCore)* dataArray); 675 version(BindBlend2D_Static) BLResult blFontDataCreateFromData(BLFontDataCore* self, const(void)* data, size_t dataSize, BLDestroyImplFunc destroyFunc, void* destroyData); 676 version(BindBlend2D_Static) bool blFontDataEquals(const(BLFontDataCore)* a, const(BLFontDataCore)* b); 677 version(BindBlend2D_Static) BLResult blFontDataListTags(const(BLFontDataCore)* self, uint faceIndex, BLArrayCore* dst); 678 version(BindBlend2D_Static) size_t blFontDataQueryTables(const(BLFontDataCore)* self, uint faceIndex, BLFontTable* dst, const(BLTag)* tags, size_t count); 679 680 version(BindBlend2D_Static) BLResult blFontFaceInit(BLFontFaceCore* self); 681 version(BindBlend2D_Static) BLResult blFontFaceDestroy(BLFontFaceCore* self); 682 version(BindBlend2D_Static) BLResult blFontFaceReset(BLFontFaceCore* self); 683 version(BindBlend2D_Static) BLResult blFontFaceAssignMove(BLFontFaceCore* self, BLFontFaceCore* other); 684 version(BindBlend2D_Static) BLResult blFontFaceAssignWeak(BLFontFaceCore* self, const(BLFontFaceCore)* other); 685 version(BindBlend2D_Static) bool blFontFaceEquals(const(BLFontFaceCore)* a, const(BLFontFaceCore)* b); 686 version(BindBlend2D_Static) BLResult blFontFaceCreateFromFile(BLFontFaceCore* self, const(char)* fileName, uint readFlags); 687 version(BindBlend2D_Static) BLResult blFontFaceCreateFromData(BLFontFaceCore* self, const(BLFontDataCore)* fontData, uint faceIndex); 688 version(BindBlend2D_Static) BLResult blFontFaceGetFaceInfo(const(BLFontFaceCore)* self, BLFontFaceInfo* out_); 689 version(BindBlend2D_Static) BLResult blFontFaceGetDesignMetrics(const(BLFontFaceCore)* self, BLFontDesignMetrics* out_); 690 version(BindBlend2D_Static) BLResult blFontFaceGetUnicodeCoverage(const(BLFontFaceCore)* self, BLFontUnicodeCoverage* out_); 691 692 version(BindBlend2D_Static) BLResult blFontManagerInit(BLFontManagerCore* self); 693 version(BindBlend2D_Static) BLResult blFontManagerInitNew(BLFontManagerCore* self); 694 version(BindBlend2D_Static) BLResult blFontManagerDestroy(BLFontManagerCore* self); 695 version(BindBlend2D_Static) BLResult blFontManagerReset(BLFontManagerCore* self); 696 version(BindBlend2D_Static) BLResult blFontManagerAssignMove(BLFontManagerCore* self, BLFontManagerCore* other); 697 version(BindBlend2D_Static) BLResult blFontManagerAssignWeak(BLFontManagerCore* self, const(BLFontManagerCore)* other); 698 version(BindBlend2D_Static) BLResult blFontManagerCreate(BLFontManagerCore* self); 699 version(BindBlend2D_Static) size_t blFontManagerGetFaceCount(const(BLFontManagerCore)* self); 700 version(BindBlend2D_Static) size_t blFontManagerGetFamilyCount(const(BLFontManagerCore)* self); 701 version(BindBlend2D_Static) bool blFontManagerHasFace(const(BLFontManagerCore)* self, const(BLFontFaceCore)* face); 702 version(BindBlend2D_Static) BLResult blFontManagerAddFace(BLFontManagerCore* self, const(BLFontFaceCore)* face); 703 version(BindBlend2D_Static) BLResult blFontManagerQueryFace(const(BLFontManagerCore)* self, const(char)* name, size_t nameSize, const(BLFontQueryProperties)* properties, BLFontFaceCore* out_); 704 version(BindBlend2D_Static) BLResult blFontManagerQueryFacesByFamilyName(const(BLFontManagerCore)* self, const(char)* name, size_t nameSize, BLArrayCore* out_); 705 version(BindBlend2D_Static) bool blFontManagerEquals(const(BLFontManagerCore)* a, const(BLFontManagerCore)* b); 706 707 version(BindBlend2D_Static) BLResult blFormatInfoQuery(BLFormatInfo* self, uint format); 708 version(BindBlend2D_Static) BLResult blFormatInfoSanitize(BLFormatInfo* self); 709 710 version(BindBlend2D_Static) BLResult blGlyphBufferInit(BLGlyphBufferCore* self); 711 version(BindBlend2D_Static) BLResult blGlyphBufferInitMove(BLGlyphBufferCore* self, BLGlyphBufferCore* other); 712 version(BindBlend2D_Static) BLResult blGlyphBufferDestroy(BLGlyphBufferCore* self); 713 version(BindBlend2D_Static) BLResult blGlyphBufferReset(BLGlyphBufferCore* self); 714 version(BindBlend2D_Static) BLResult blGlyphBufferClear(BLGlyphBufferCore* self); 715 version(BindBlend2D_Static) size_t blGlyphBufferGetSize(const(BLGlyphBufferCore)* self); 716 version(BindBlend2D_Static) uint blGlyphBufferGetFlags(const(BLGlyphBufferCore)* self); 717 version(BindBlend2D_Static) const(BLGlyphRun)* blGlyphBufferGetGlyphRun(const(BLGlyphBufferCore)* self); 718 version(BindBlend2D_Static) const(uint)* blGlyphBufferGetContent(const(BLGlyphBufferCore)* self); 719 version(BindBlend2D_Static) const(BLGlyphInfo)* blGlyphBufferGetInfoData(const(BLGlyphBufferCore)* self); 720 version(BindBlend2D_Static) const(BLGlyphPlacement)* blGlyphBufferGetPlacementData(const(BLGlyphBufferCore)* self); 721 version(BindBlend2D_Static) BLResult blGlyphBufferSetText(BLGlyphBufferCore* self, const(void)* textData, size_t size, uint encoding); 722 version(BindBlend2D_Static) BLResult blGlyphBufferSetGlyphs(BLGlyphBufferCore* self, const(uint)* glyphData, size_t size); 723 version(BindBlend2D_Static) BLResult blGlyphBufferSetGlyphsFromStruct(BLGlyphBufferCore* self, const(void)* glyphData, size_t size, size_t glyphIdSize, intptr_t glyphIdAdvance); 724 725 version(BindBlend2D_Static) BLResult blGradientInit(BLGradientCore* self); 726 version(BindBlend2D_Static) BLResult blGradientInitAs(BLGradientCore* self, uint type, const(void)* values, uint extendMode, const(BLGradientStop)* stops, size_t n, const(BLMatrix2D)* m); 727 version(BindBlend2D_Static) BLResult blGradientDestroy(BLGradientCore* self); 728 version(BindBlend2D_Static) BLResult blGradientReset(BLGradientCore* self); 729 version(BindBlend2D_Static) BLResult blGradientAssignMove(BLGradientCore* self, BLGradientCore* other); 730 version(BindBlend2D_Static) BLResult blGradientAssignWeak(BLGradientCore* self, const(BLGradientCore)* other); 731 version(BindBlend2D_Static) BLResult blGradientCreate(BLGradientCore* self, uint type, const(void)* values, uint extendMode, const(BLGradientStop)* stops, size_t n, const(BLMatrix2D)* m); 732 version(BindBlend2D_Static) BLResult blGradientShrink(BLGradientCore* self); 733 version(BindBlend2D_Static) BLResult blGradientReserve(BLGradientCore* self, size_t n); 734 version(BindBlend2D_Static) uint blGradientGetType(const(BLGradientCore)* self); 735 version(BindBlend2D_Static) BLResult blGradientSetType(BLGradientCore* self, uint type); 736 version(BindBlend2D_Static) double blGradientGetValue(const(BLGradientCore)* self, size_t index); 737 version(BindBlend2D_Static) BLResult blGradientSetValue(BLGradientCore* self, size_t index, double value); 738 version(BindBlend2D_Static) BLResult blGradientSetValues(BLGradientCore* self, size_t index, const(double)* values, size_t n); 739 version(BindBlend2D_Static) uint blGradientGetExtendMode(BLGradientCore* self); 740 version(BindBlend2D_Static) BLResult blGradientSetExtendMode(BLGradientCore* self, uint extendMode); 741 version(BindBlend2D_Static) size_t blGradientGetSize(const(BLGradientCore)* self); 742 version(BindBlend2D_Static) size_t blGradientGetCapacity(const(BLGradientCore)* self); 743 version(BindBlend2D_Static) const(BLGradientStop)* blGradientGetStops(const(BLGradientCore)* self); 744 version(BindBlend2D_Static) BLResult blGradientResetStops(BLGradientCore* self); 745 version(BindBlend2D_Static) BLResult blGradientAssignStops(BLGradientCore* self, const(BLGradientStop)* stops, size_t n); 746 version(BindBlend2D_Static) BLResult blGradientAddStopRgba32(BLGradientCore* self, double offset, uint argb32); 747 version(BindBlend2D_Static) BLResult blGradientAddStopRgba64(BLGradientCore* self, double offset, ulong argb64); 748 version(BindBlend2D_Static) BLResult blGradientRemoveStop(BLGradientCore* self, size_t index); 749 version(BindBlend2D_Static) BLResult blGradientRemoveStopByOffset(BLGradientCore* self, double offset, uint all); 750 version(BindBlend2D_Static) BLResult blGradientRemoveStops(BLGradientCore* self, size_t rStart, size_t rEnd); 751 version(BindBlend2D_Static) BLResult blGradientRemoveStopsFromTo(BLGradientCore* self, double offsetMin, double offsetMax); 752 version(BindBlend2D_Static) BLResult blGradientReplaceStopRgba32(BLGradientCore* self, size_t index, double offset, uint rgba32); 753 version(BindBlend2D_Static) BLResult blGradientReplaceStopRgba64(BLGradientCore* self, size_t index, double offset, ulong rgba64); 754 version(BindBlend2D_Static) size_t blGradientIndexOfStop(const(BLGradientCore)* self, double offset); 755 version(BindBlend2D_Static) BLResult blGradientApplyMatrixOp(BLGradientCore* self, uint opType, const(void)* opData); 756 version(BindBlend2D_Static) bool blGradientEquals(const(BLGradientCore)* a, const(BLGradientCore)* b); 757 758 version(BindBlend2D_Static) BLResult blImageInit(BLImageCore* self); 759 version(BindBlend2D_Static) BLResult blImageInitAs(BLImageCore* self, int w, int h, uint format); 760 version(BindBlend2D_Static) BLResult blImageInitAsFromData(BLImageCore* self, int w, int h, uint format, void* pixelData, intptr_t stride, BLDestroyImplFunc destroyFunc, void* destroyData); 761 version(BindBlend2D_Static) BLResult blImageDestroy(BLImageCore* self); 762 version(BindBlend2D_Static) BLResult blImageReset(BLImageCore* self); 763 version(BindBlend2D_Static) BLResult blImageAssignMove(BLImageCore* self, BLImageCore* other); 764 version(BindBlend2D_Static) BLResult blImageAssignWeak(BLImageCore* self, const(BLImageCore)* other); 765 version(BindBlend2D_Static) BLResult blImageAssignDeep(BLImageCore* self, const(BLImageCore)* other); 766 version(BindBlend2D_Static) BLResult blImageCreate(BLImageCore* self, int w, int h, uint format); 767 version(BindBlend2D_Static) BLResult blImageCreateFromData(BLImageCore* self, int w, int h, uint format, void* pixelData, intptr_t stride, BLDestroyImplFunc destroyFunc, void* destroyData); 768 version(BindBlend2D_Static) BLResult blImageGetData(const(BLImageCore)* self, BLImageData* dataOut); 769 version(BindBlend2D_Static) BLResult blImageMakeMutable(BLImageCore* self, BLImageData* dataOut); 770 version(BindBlend2D_Static) BLResult blImageConvert(BLImageCore* self, uint format); 771 version(BindBlend2D_Static) bool blImageEquals(const(BLImageCore)* a, const(BLImageCore)* b); 772 version(BindBlend2D_Static) BLResult blImageScale(BLImageCore* dst, const(BLImageCore)* src, const(BLSizeI)* size, uint filter, const(BLImageScaleOptions)* options); 773 version(BindBlend2D_Static) BLResult blImageReadFromFile(BLImageCore* self, const(char)* fileName, const(BLArrayCore)* codecs); 774 version(BindBlend2D_Static) BLResult blImageReadFromData(BLImageCore* self, const(void)* data, size_t size, const(BLArrayCore)* codecs); 775 version(BindBlend2D_Static) BLResult blImageWriteToFile(const(BLImageCore)* self, const(char)* fileName, const(BLImageCodecCore)* codec); 776 version(BindBlend2D_Static) BLResult blImageWriteToData(const(BLImageCore)* self, BLArrayCore* dst, const(BLImageCodecCore)* codec); 777 778 version(BindBlend2D_Static) BLResult blImageCodecInit(BLImageCodecCore* self); 779 version(BindBlend2D_Static) BLResult blImageCodecDestroy(BLImageCodecCore* self); 780 version(BindBlend2D_Static) BLResult blImageCodecReset(BLImageCodecCore* self); 781 version(BindBlend2D_Static) BLResult blImageCodecAssignWeak(BLImageCodecCore* self, const(BLImageCodecCore)* other); 782 version(BindBlend2D_Static) BLResult blImageCodecFindByName(BLImageCodecCore* self, const(char)* name, size_t size, const(BLArrayCore)* codecs); 783 version(BindBlend2D_Static) BLResult blImageCodecFindByExtension(BLImageCodecCore* self, const(char)* name, size_t size, const(BLArrayCore)* codecs); 784 version(BindBlend2D_Static) BLResult blImageCodecFindByData(BLImageCodecCore* self, const(void)* data, size_t size, const(BLArrayCore)* codecs); 785 version(BindBlend2D_Static) uint blImageCodecInspectData(const(BLImageCodecCore)* self, const(void)* data, size_t size); 786 version(BindBlend2D_Static) BLResult blImageCodecCreateDecoder(const(BLImageCodecCore)* self, BLImageDecoderCore* dst); 787 version(BindBlend2D_Static) BLResult blImageCodecCreateEncoder(const(BLImageCodecCore)* self, BLImageEncoderCore* dst); 788 789 version(BindBlend2D_Static) BLResult blImageCodecArrayInitBuiltInCodecs(BLArrayCore* self); 790 version(BindBlend2D_Static) BLResult blImageCodecArrayAssignBuiltInCodecs(BLArrayCore* self); 791 version(BindBlend2D_Static) BLResult blImageCodecAddToBuiltIn(const(BLImageCodecCore)* codec); 792 version(BindBlend2D_Static) BLResult blImageCodecRemoveFromBuiltIn(const(BLImageCodecCore)* codec); 793 794 version(BindBlend2D_Static) BLResult blImageDecoderInit(BLImageDecoderCore* self); 795 version(BindBlend2D_Static) BLResult blImageDecoderDestroy(BLImageDecoderCore* self); 796 version(BindBlend2D_Static) BLResult blImageDecoderReset(BLImageDecoderCore* self); 797 version(BindBlend2D_Static) BLResult blImageDecoderAssignMove(BLImageDecoderCore* self, BLImageDecoderCore* other); 798 version(BindBlend2D_Static) BLResult blImageDecoderAssignWeak(BLImageDecoderCore* self, const(BLImageDecoderCore)* other); 799 version(BindBlend2D_Static) BLResult blImageDecoderRestart(BLImageDecoderCore* self); 800 version(BindBlend2D_Static) BLResult blImageDecoderReadInfo(BLImageDecoderCore* self, BLImageInfo* infoOut, const(ubyte)* data, size_t size); 801 version(BindBlend2D_Static) BLResult blImageDecoderReadFrame(BLImageDecoderCore* self, BLImageCore* imageOut, const(ubyte)* data, size_t size); 802 803 version(BindBlend2D_Static) BLResult blImageEncoderInit(BLImageEncoderCore* self); 804 version(BindBlend2D_Static) BLResult blImageEncoderDestroy(BLImageEncoderCore* self); 805 version(BindBlend2D_Static) BLResult blImageEncoderReset(BLImageEncoderCore* self); 806 version(BindBlend2D_Static) BLResult blImageEncoderAssignMove(BLImageEncoderCore* self, BLImageEncoderCore* other); 807 version(BindBlend2D_Static) BLResult blImageEncoderAssignWeak(BLImageEncoderCore* self, const(BLImageEncoderCore)* other); 808 version(BindBlend2D_Static) BLResult blImageEncoderRestart(BLImageEncoderCore* self); 809 version(BindBlend2D_Static) BLResult blImageEncoderWriteFrame(BLImageEncoderCore* self, BLArrayCore* dst, const(BLImageCore)* image); 810 811 version(BindBlend2D_Static) BLResult blMatrix2DSetIdentity(BLMatrix2D* self); 812 version(BindBlend2D_Static) BLResult blMatrix2DSetTranslation(BLMatrix2D* self, double x, double y); 813 version(BindBlend2D_Static) BLResult blMatrix2DSetScaling(BLMatrix2D* self, double x, double y); 814 version(BindBlend2D_Static) BLResult blMatrix2DSetSkewing(BLMatrix2D* self, double x, double y); 815 version(BindBlend2D_Static) BLResult blMatrix2DSetRotation(BLMatrix2D* self, double angle, double cx, double cy); 816 version(BindBlend2D_Static) BLResult blMatrix2DApplyOp(BLMatrix2D* self, uint opType, const(void)* opData); 817 version(BindBlend2D_Static) BLResult blMatrix2DInvert(BLMatrix2D* dst, const(BLMatrix2D)* src); 818 version(BindBlend2D_Static) uint blMatrix2DGetType(const(BLMatrix2D)* self); 819 version(BindBlend2D_Static) BLResult blMatrix2DMapPointDArray(const(BLMatrix2D)* self, BLPoint* dst, const(BLPoint)* src, size_t count); 820 821 version(BindBlend2D_Static) BLResult blPathInit(BLPathCore* self); 822 version(BindBlend2D_Static) BLResult blPathDestroy(BLPathCore* self); 823 version(BindBlend2D_Static) BLResult blPathReset(BLPathCore* self); 824 version(BindBlend2D_Static) size_t blPathGetSize(const(BLPathCore)* self); 825 version(BindBlend2D_Static) size_t blPathGetCapacity(const(BLPathCore)* self); 826 version(BindBlend2D_Static) const(ubyte)* blPathGetCommandData(const(BLPathCore)* self); 827 version(BindBlend2D_Static) const(BLPoint)* blPathGetVertexData(const(BLPathCore)* self); 828 version(BindBlend2D_Static) BLResult blPathClear(BLPathCore* self); 829 version(BindBlend2D_Static) BLResult blPathShrink(BLPathCore* self); 830 version(BindBlend2D_Static) BLResult blPathReserve(BLPathCore* self, size_t n); 831 version(BindBlend2D_Static) BLResult blPathModifyOp(BLPathCore* self, uint op, size_t n, ubyte** cmdDataOut, BLPoint** vtxDataOut); 832 version(BindBlend2D_Static) BLResult blPathAssignMove(BLPathCore* self, BLPathCore* other); 833 version(BindBlend2D_Static) BLResult blPathAssignWeak(BLPathCore* self, const(BLPathCore)* other); 834 version(BindBlend2D_Static) BLResult blPathAssignDeep(BLPathCore* self, const(BLPathCore)* other); 835 version(BindBlend2D_Static) BLResult blPathSetVertexAt(BLPathCore* self, size_t index, uint cmd, double x, double y); 836 version(BindBlend2D_Static) BLResult blPathMoveTo(BLPathCore* self, double x0, double y0); 837 version(BindBlend2D_Static) BLResult blPathLineTo(BLPathCore* self, double x1, double y1); 838 version(BindBlend2D_Static) BLResult blPathPolyTo(BLPathCore* self, const(BLPoint)* poly, size_t count); 839 version(BindBlend2D_Static) BLResult blPathQuadTo(BLPathCore* self, double x1, double y1, double x2, double y2); 840 version(BindBlend2D_Static) BLResult blPathCubicTo(BLPathCore* self, double x1, double y1, double x2, double y2, double x3, double y3); 841 version(BindBlend2D_Static) BLResult blPathSmoothQuadTo(BLPathCore* self, double x2, double y2); 842 version(BindBlend2D_Static) BLResult blPathSmoothCubicTo(BLPathCore* self, double x2, double y2, double x3, double y3); 843 version(BindBlend2D_Static) BLResult blPathArcTo(BLPathCore* self, double x, double y, double rx, double ry, double start, double sweep, bool forceMoveTo); 844 version(BindBlend2D_Static) BLResult blPathArcQuadrantTo(BLPathCore* self, double x1, double y1, double x2, double y2); 845 version(BindBlend2D_Static) BLResult blPathEllipticArcTo(BLPathCore* self, double rx, double ry, double xAxisRotation, bool largeArcFlag, bool sweepFlag, double x1, double y1); 846 version(BindBlend2D_Static) BLResult blPathClose(BLPathCore* self); 847 version(BindBlend2D_Static) BLResult blPathAddGeometry(BLPathCore* self, uint geometryType, const(void)* geometryData, const(BLMatrix2D)* m, uint dir); 848 version(BindBlend2D_Static) BLResult blPathAddBoxI(BLPathCore* self, const(BLBoxI)* box, uint dir); 849 version(BindBlend2D_Static) BLResult blPathAddBoxD(BLPathCore* self, const(BLBox)* box, uint dir); 850 version(BindBlend2D_Static) BLResult blPathAddRectI(BLPathCore* self, const(BLRectI)* rect, uint dir); 851 version(BindBlend2D_Static) BLResult blPathAddRectD(BLPathCore* self, const(BLRect)* rect, uint dir); 852 version(BindBlend2D_Static) BLResult blPathAddPath(BLPathCore* self, const(BLPathCore)* other, const(BLRange)* range); 853 version(BindBlend2D_Static) BLResult blPathAddTranslatedPath(BLPathCore* self, const(BLPathCore)* other, const(BLRange)* range, const(BLPoint)* p); 854 version(BindBlend2D_Static) BLResult blPathAddTransformedPath(BLPathCore* self, const(BLPathCore)* other, const(BLRange)* range, const(BLMatrix2D)* m); 855 version(BindBlend2D_Static) BLResult blPathAddReversedPath(BLPathCore* self, const(BLPathCore)* other, const(BLRange)* range, uint reverseMode); 856 version(BindBlend2D_Static) BLResult blPathAddStrokedPath(BLPathCore* self, const(BLPathCore)* other, const(BLRange)* range, const(BLStrokeOptionsCore)* options, const(BLApproximationOptions)* approx); 857 version(BindBlend2D_Static) BLResult blPathRemoveRange(BLPathCore* self, const(BLRange)* range); 858 version(BindBlend2D_Static) BLResult blPathTranslate(BLPathCore* self, const(BLRange)* range, const(BLPoint)* p); 859 version(BindBlend2D_Static) BLResult blPathTransform(BLPathCore* self, const(BLRange)* range, const(BLMatrix2D)* m); 860 version(BindBlend2D_Static) BLResult blPathFitTo(BLPathCore* self, const(BLRange)* range, const(BLRect)* rect, uint fitFlags); 861 version(BindBlend2D_Static) bool blPathEquals(const(BLPathCore)* a, const(BLPathCore)* b); 862 version(BindBlend2D_Static) BLResult blPathGetInfoFlags(const(BLPathCore)* self, uint* flagsOut); 863 version(BindBlend2D_Static) BLResult blPathGetControlBox(const(BLPathCore)* self, BLBox* boxOut); 864 version(BindBlend2D_Static) BLResult blPathGetBoundingBox(const(BLPathCore)* self, BLBox* boxOut); 865 version(BindBlend2D_Static) BLResult blPathGetFigureRange(const(BLPathCore)* self, size_t index, BLRange* rangeOut); 866 version(BindBlend2D_Static) BLResult blPathGetLastVertex(const(BLPathCore)* self, BLPoint* vtxOut); 867 version(BindBlend2D_Static) BLResult blPathGetClosestVertex(const(BLPathCore)* self, const(BLPoint)* p, double maxDistance, size_t* indexOut, double* distanceOut); 868 version(BindBlend2D_Static) uint blPathHitTest(const(BLPathCore)* self, const(BLPoint)* p, uint fillRule); 869 870 version(BindBlend2D_Static) BLResult blPatternInit(BLPatternCore* self); 871 version(BindBlend2D_Static) BLResult blPatternInitAs(BLPatternCore* self, const(BLImageCore)* image, const(BLRectI)* area, uint extendMode, const(BLMatrix2D)* m); 872 version(BindBlend2D_Static) BLResult blPatternDestroy(BLPatternCore* self); 873 version(BindBlend2D_Static) BLResult blPatternReset(BLPatternCore* self); 874 version(BindBlend2D_Static) BLResult blPatternAssignMove(BLPatternCore* self, BLPatternCore* other); 875 version(BindBlend2D_Static) BLResult blPatternAssignWeak(BLPatternCore* self, const(BLPatternCore)* other); 876 version(BindBlend2D_Static) BLResult blPatternAssignDeep(BLPatternCore* self, const(BLPatternCore)* other); 877 version(BindBlend2D_Static) BLResult blPatternCreate(BLPatternCore* self, const(BLImageCore)* image, const(BLRectI)* area, uint extendMode, const(BLMatrix2D)* m); 878 version(BindBlend2D_Static) BLResult blPatternSetImage(BLPatternCore* self, const(BLImageCore)* image, const(BLRectI)* area); 879 version(BindBlend2D_Static) BLResult blPatternSetArea(BLPatternCore* self, const(BLRectI)* area); 880 version(BindBlend2D_Static) BLResult blPatternSetExtendMode(BLPatternCore* self, uint extendMode); 881 version(BindBlend2D_Static) BLResult blPatternApplyMatrixOp(BLPatternCore* self, uint opType, const(void)* opData); 882 version(BindBlend2D_Static) bool blPatternEquals(const(BLPatternCore)* a, const(BLPatternCore)* b); 883 884 version(BindBlend2D_Static) BLResult blPixelConverterInit(BLPixelConverterCore* self); 885 version(BindBlend2D_Static) BLResult blPixelConverterInitWeak(BLPixelConverterCore* self, const(BLPixelConverterCore)* other); 886 version(BindBlend2D_Static) BLResult blPixelConverterDestroy(BLPixelConverterCore* self); 887 version(BindBlend2D_Static) BLResult blPixelConverterReset(BLPixelConverterCore* self); 888 version(BindBlend2D_Static) BLResult blPixelConverterAssign(BLPixelConverterCore* self, const(BLPixelConverterCore)* other); 889 version(BindBlend2D_Static) BLResult blPixelConverterCreate(BLPixelConverterCore* self, const(BLFormatInfo)* dstInfo, const(BLFormatInfo)* srcInfo, uint createFlags); 890 891 version(BindBlend2D_Static) BLResult blPixelConverterConvert( 892 const(BLPixelConverterCore)* self, 893 void* dstData, 894 intptr_t dstStride, 895 const(void)* srcData, 896 intptr_t srcStride, 897 uint w, 898 uint h, 899 const(BLPixelConverterOptions)* options); 900 901 version(BindBlend2D_Static) BLResult blRandomReset(BLRandom* self, ulong seed); 902 version(BindBlend2D_Static) uint blRandomNextUInt32(BLRandom* self); 903 version(BindBlend2D_Static) ulong blRandomNextUInt64(BLRandom* self); 904 version(BindBlend2D_Static) double blRandomNextDouble(BLRandom* self); 905 906 version(BindBlend2D_Static) BLResult blRegionInit(BLRegionCore* self); 907 version(BindBlend2D_Static) BLResult blRegionDestroy(BLRegionCore* self); 908 version(BindBlend2D_Static) BLResult blRegionReset(BLRegionCore* self); 909 version(BindBlend2D_Static) size_t blRegionGetSize(const(BLRegionCore)* self); 910 version(BindBlend2D_Static) size_t blRegionGetCapacity(const(BLRegionCore)* self); 911 version(BindBlend2D_Static) const(BLBoxI)* blRegionGetData(const(BLRegionCore)* self); 912 version(BindBlend2D_Static) BLResult blRegionClear(BLRegionCore* self); 913 version(BindBlend2D_Static) BLResult blRegionShrink(BLRegionCore* self); 914 version(BindBlend2D_Static) BLResult blRegionReserve(BLRegionCore* self, size_t n); 915 version(BindBlend2D_Static) BLResult blRegionAssignMove(BLRegionCore* self, BLRegionCore* other); 916 version(BindBlend2D_Static) BLResult blRegionAssignWeak(BLRegionCore* self, const(BLRegionCore)* other); 917 version(BindBlend2D_Static) BLResult blRegionAssignDeep(BLRegionCore* self, const(BLRegionCore)* other); 918 version(BindBlend2D_Static) BLResult blRegionAssignBoxI(BLRegionCore* self, const(BLBoxI)* src); 919 version(BindBlend2D_Static) BLResult blRegionAssignBoxIArray(BLRegionCore* self, const(BLBoxI)* data, size_t n); 920 version(BindBlend2D_Static) BLResult blRegionAssignRectI(BLRegionCore* self, const(BLRectI)* rect); 921 version(BindBlend2D_Static) BLResult blRegionAssignRectIArray(BLRegionCore* self, const(BLRectI)* data, size_t n); 922 version(BindBlend2D_Static) BLResult blRegionCombine(BLRegionCore* self, const(BLRegionCore)* a, const(BLRegionCore)* b, uint booleanOp); 923 version(BindBlend2D_Static) BLResult blRegionCombineRB(BLRegionCore* self, const(BLRegionCore)* a, const(BLBoxI)* b, uint booleanOp); 924 version(BindBlend2D_Static) BLResult blRegionCombineBR(BLRegionCore* self, const(BLBoxI)* a, const(BLRegionCore)* b, uint booleanOp); 925 version(BindBlend2D_Static) BLResult blRegionCombineBB(BLRegionCore* self, const(BLBoxI)* a, const(BLBoxI)* b, uint booleanOp); 926 version(BindBlend2D_Static) BLResult blRegionTranslate(BLRegionCore* self, const(BLRegionCore)* r, const(BLPointI)* pt); 927 version(BindBlend2D_Static) BLResult blRegionTranslateAndClip(BLRegionCore* self, const(BLRegionCore)* r, const(BLPointI)* pt, const(BLBoxI)* clipBox); 928 version(BindBlend2D_Static) BLResult blRegionIntersectAndClip(BLRegionCore* self, const(BLRegionCore)* a, const(BLRegionCore)* b, const(BLBoxI)* clipBox); 929 version(BindBlend2D_Static) bool blRegionEquals(const(BLRegionCore)* a, const(BLRegionCore)* b); 930 version(BindBlend2D_Static) uint blRegionGetType(const(BLRegionCore)* self); 931 version(BindBlend2D_Static) uint blRegionHitTest(const(BLRegionCore)* self, const(BLPointI)* pt); 932 version(BindBlend2D_Static) uint blRegionHitTestBoxI(const(BLRegionCore)* self, const(BLBoxI)* box); 933 934 version(BindBlend2D_Static) BLResult blRuntimeInit(); 935 version(BindBlend2D_Static) BLResult blRuntimeShutdown(); 936 version(BindBlend2D_Static) BLResult blRuntimeCleanup(uint cleanupFlags); 937 version(BindBlend2D_Static) BLResult blRuntimeQueryInfo(uint infoType, void* infoOut); 938 version(BindBlend2D_Static) BLResult blRuntimeMessageOut(const(char)* msg); 939 version(BindBlend2D_Static) BLResult blRuntimeMessageFmt(const(char)* fmt, ...); 940 version(BindBlend2D_Static) BLResult blRuntimeMessageVFmt(const(char)* fmt, va_list ap); 941 942 version(BindBlend2D_Static) void blRuntimeAssertionFailure(const(char)* file, int line, const(char)* msg); 943 944 //BLResult blResultFromWinError(uint e); 945 946 version(BindBlend2D_Static) BLResult blStringInit(BLStringCore* self); 947 version(BindBlend2D_Static) BLResult blStringInitWithData(BLStringCore* self, const(char)* str, size_t size); 948 version(BindBlend2D_Static) BLResult blStringDestroy(BLStringCore* self); 949 version(BindBlend2D_Static) BLResult blStringReset(BLStringCore* self); 950 version(BindBlend2D_Static) size_t blStringGetSize(const(BLStringCore)* self); 951 version(BindBlend2D_Static) size_t blStringGetCapacity(const(BLStringCore)* self); 952 version(BindBlend2D_Static) const(char)* blStringGetData(const(BLStringCore)* self); 953 version(BindBlend2D_Static) BLResult blStringClear(BLStringCore* self); 954 version(BindBlend2D_Static) BLResult blStringShrink(BLStringCore* self); 955 version(BindBlend2D_Static) BLResult blStringReserve(BLStringCore* self, size_t n); 956 version(BindBlend2D_Static) BLResult blStringResize(BLStringCore* self, size_t n, char fill); 957 version(BindBlend2D_Static) BLResult blStringMakeMutable(BLStringCore* self, char** dataOut); 958 version(BindBlend2D_Static) BLResult blStringModifyOp(BLStringCore* self, uint op, size_t n, char** dataOut); 959 version(BindBlend2D_Static) BLResult blStringInsertOp(BLStringCore* self, size_t index, size_t n, char** dataOut); 960 version(BindBlend2D_Static) BLResult blStringAssignMove(BLStringCore* self, BLStringCore* other); 961 version(BindBlend2D_Static) BLResult blStringAssignWeak(BLStringCore* self, const(BLStringCore)* other); 962 version(BindBlend2D_Static) BLResult blStringAssignDeep(BLStringCore* self, const(BLStringCore)* other); 963 version(BindBlend2D_Static) BLResult blStringAssignData(BLStringCore* self, const(char)* str, size_t n); 964 version(BindBlend2D_Static) BLResult blStringApplyOpChar(BLStringCore* self, uint op, char c, size_t n); 965 version(BindBlend2D_Static) BLResult blStringApplyOpData(BLStringCore* self, uint op, const(char)* str, size_t n); 966 version(BindBlend2D_Static) BLResult blStringApplyOpString(BLStringCore* self, uint op, const(BLStringCore)* other); 967 version(BindBlend2D_Static) BLResult blStringApplyOpFormat(BLStringCore* self, uint op, const(char)* fmt, ...); 968 version(BindBlend2D_Static) BLResult blStringApplyOpFormatV(BLStringCore* self, uint op, const(char)* fmt, va_list ap); 969 version(BindBlend2D_Static) BLResult blStringInsertChar(BLStringCore* self, size_t index, char c, size_t n); 970 version(BindBlend2D_Static) BLResult blStringInsertData(BLStringCore* self, size_t index, const(char)* str, size_t n); 971 version(BindBlend2D_Static) BLResult blStringInsertString(BLStringCore* self, size_t index, const(BLStringCore)* other); 972 version(BindBlend2D_Static) BLResult blStringRemoveRange(BLStringCore* self, size_t rStart, size_t rEnd); 973 version(BindBlend2D_Static) bool blStringEquals(const(BLStringCore)* self, const(BLStringCore)* other); 974 version(BindBlend2D_Static) bool blStringEqualsData(const(BLStringCore)* self, const(char)* str, size_t n); 975 version(BindBlend2D_Static) int blStringCompare(const(BLStringCore)* self, const(BLStringCore)* other); 976 version(BindBlend2D_Static) int blStringCompareData(const(BLStringCore)* self, const(char)* str, size_t n); 977 978 version(BindBlend2D_Static) BLResult blStrokeOptionsInit(BLStrokeOptionsCore* self); 979 version(BindBlend2D_Static) BLResult blStrokeOptionsInitMove(BLStrokeOptionsCore* self, BLStrokeOptionsCore* other); 980 version(BindBlend2D_Static) BLResult blStrokeOptionsInitWeak(BLStrokeOptionsCore* self, const(BLStrokeOptionsCore)* other); 981 version(BindBlend2D_Static) BLResult blStrokeOptionsDestroy(BLStrokeOptionsCore* self); 982 version(BindBlend2D_Static) BLResult blStrokeOptionsReset(BLStrokeOptionsCore* self); 983 version(BindBlend2D_Static) BLResult blStrokeOptionsAssignMove(BLStrokeOptionsCore* self, BLStrokeOptionsCore* other); 984 version(BindBlend2D_Static) BLResult blStrokeOptionsAssignWeak(BLStrokeOptionsCore* self, const(BLStrokeOptionsCore)* other); 985 986 version(BindBlend2D_Static) BLResult blStyleInit(BLStyleCore* self); 987 version(BindBlend2D_Static) BLResult blStyleInitMove(BLStyleCore* self, BLStyleCore* other); 988 version(BindBlend2D_Static) BLResult blStyleInitWeak(BLStyleCore* self, const(BLStyleCore)* other); 989 version(BindBlend2D_Static) BLResult blStyleInitRgba(BLStyleCore* self, const(BLRgba)* rgba); 990 version(BindBlend2D_Static) BLResult blStyleInitRgba32(BLStyleCore* self, uint rgba32); 991 version(BindBlend2D_Static) BLResult blStyleInitRgba64(BLStyleCore* self, ulong rgba64); 992 version(BindBlend2D_Static) BLResult blStyleInitObject(BLStyleCore* self, const(void)* object); 993 version(BindBlend2D_Static) BLResult blStyleDestroy(BLStyleCore* self); 994 version(BindBlend2D_Static) BLResult blStyleReset(BLStyleCore* self); 995 version(BindBlend2D_Static) BLResult blStyleAssignMove(BLStyleCore* self, BLStyleCore* other); 996 version(BindBlend2D_Static) BLResult blStyleAssignWeak(BLStyleCore* self, const(BLStyleCore)* other); 997 version(BindBlend2D_Static) BLResult blStyleAssignRgba(BLStyleCore* self, const(BLRgba)* rgba); 998 version(BindBlend2D_Static) BLResult blStyleAssignRgba32(BLStyleCore* self, uint rgba32); 999 version(BindBlend2D_Static) BLResult blStyleAssignRgba64(BLStyleCore* self, ulong rgba64); 1000 version(BindBlend2D_Static) BLResult blStyleAssignObject(BLStyleCore* self, const(void)* object); 1001 version(BindBlend2D_Static) uint blStyleGetType(const(BLStyleCore)* self); 1002 version(BindBlend2D_Static) BLResult blStyleGetRgba(const(BLStyleCore)* self, BLRgba* rgbaOut); 1003 version(BindBlend2D_Static) BLResult blStyleGetRgba32(const(BLStyleCore)* self, uint* rgba32Out); 1004 version(BindBlend2D_Static) BLResult blStyleGetRgba64(const(BLStyleCore)* self, ulong* rgba64Out); 1005 version(BindBlend2D_Static) BLResult blStyleGetObject(const(BLStyleCore)* self, void* object); 1006 version(BindBlend2D_Static) bool blStyleEquals(const(BLStyleCore)* a, const(BLStyleCore)* b); 1007 1008 version(BindBlend2D_Static) BLResult blVariantInit(void* self); 1009 version(BindBlend2D_Static) BLResult blVariantInitMove(void* self, void* other); 1010 version(BindBlend2D_Static) BLResult blVariantInitWeak(void* self, const(void)* other); 1011 version(BindBlend2D_Static) BLResult blVariantDestroy(void* self); 1012 version(BindBlend2D_Static) BLResult blVariantReset(void* self); 1013 version(BindBlend2D_Static) uint blVariantGetImplType(const(void)* self); 1014 version(BindBlend2D_Static) BLResult blVariantAssignMove(void* self, void* other); 1015 version(BindBlend2D_Static) BLResult blVariantAssignWeak(void* self, const(void)* other); 1016 version(BindBlend2D_Static) bool blVariantEquals(const(void)* a, const(void)* b); 1017 1018 version(BindBlend2D_Static) version(Windows) BLResult blResultFromWinError(uint e); 1019 version(BindBlend2D_Static) version(Posix) BLResult blResultFromPosixError(int e); 1020 1021 //****** array.d ******// 1022 1023 extern (C): 1024 1025 struct BLArrayImpl 1026 { 1027 size_t capacity; 1028 1029 size_t refCount; 1030 1031 ubyte implType; 1032 1033 ubyte implTraits; 1034 1035 ushort memPoolData; 1036 1037 ubyte itemSize; 1038 1039 ubyte dispatchType; 1040 1041 ubyte[2] reserved; 1042 1043 union 1044 { 1045 struct 1046 { 1047 void* data; 1048 1049 size_t size; 1050 } 1051 1052 BLDataView view; 1053 } 1054 } 1055 1056 struct BLArrayCore 1057 { 1058 BLArrayImpl* impl; 1059 } 1060 1061 //****** bitarray.d ******// 1062 1063 extern (C): 1064 1065 1066 //****** context.d ******// 1067 1068 extern (C): 1069 1070 enum BLContextType 1071 { 1072 BL_CONTEXT_TYPE_NONE = 0, 1073 1074 BL_CONTEXT_TYPE_DUMMY = 1, 1075 1076 BL_CONTEXT_TYPE_RASTER = 3, 1077 1078 BL_CONTEXT_TYPE_COUNT = 4 1079 } 1080 1081 enum BLContextHint 1082 { 1083 BL_CONTEXT_HINT_RENDERING_QUALITY = 0, 1084 1085 BL_CONTEXT_HINT_GRADIENT_QUALITY = 1, 1086 1087 BL_CONTEXT_HINT_PATTERN_QUALITY = 2, 1088 1089 BL_CONTEXT_HINT_COUNT = 8 1090 } 1091 1092 enum BLContextOpType 1093 { 1094 BL_CONTEXT_OP_TYPE_FILL = 0, 1095 1096 BL_CONTEXT_OP_TYPE_STROKE = 1, 1097 1098 BL_CONTEXT_OP_TYPE_COUNT = 2 1099 } 1100 1101 enum BLContextFlushFlags 1102 { 1103 BL_CONTEXT_FLUSH_SYNC = 0x80000000u 1104 } 1105 1106 enum BLContextCreateFlags 1107 { 1108 BL_CONTEXT_CREATE_FLAG_FALLBACK_TO_SYNC = 0x00000008u, 1109 1110 BL_CONTEXT_CREATE_FLAG_ISOLATED_THREAD_POOL = 0x01000000u, 1111 1112 BL_CONTEXT_CREATE_FLAG_ISOLATED_JIT_RUNTIME = 0x02000000u, 1113 1114 BL_CONTEXT_CREATE_FLAG_ISOLATED_JIT_LOGGING = 0x04000000u, 1115 1116 BL_CONTEXT_CREATE_FLAG_OVERRIDE_CPU_FEATURES = 0x08000000u 1117 } 1118 1119 enum BLContextProperty 1120 { 1121 BL_CONTEXT_PROPERTY_THREAD_COUNT = 0, 1122 1123 BL_CONTEXT_PROPERTY_ACCUMULATED_ERROR_FLAGS = 10 1124 } 1125 1126 enum BLContextErrorFlags 1127 { 1128 BL_CONTEXT_ERROR_FLAG_INVALID_VALUE = 0x00000001u, 1129 1130 BL_CONTEXT_ERROR_FLAG_INVALID_STATE = 0x00000002u, 1131 1132 BL_CONTEXT_ERROR_FLAG_INVALID_GEOMETRY = 0x00000004u, 1133 1134 BL_CONTEXT_ERROR_FLAG_INVALID_GLYPH = 0x00000008u, 1135 1136 BL_CONTEXT_ERROR_FLAG_INVALID_FONT = 0x00000010u, 1137 1138 BL_CONTEXT_ERROR_FLAG_THREAD_POOL_EXHAUSTED = 0x20000000u, 1139 1140 BL_CONTEXT_ERROR_FLAG_OUT_OF_MEMORY = 0x40000000u, 1141 1142 BL_CONTEXT_ERROR_FLAG_UNKNOWN_ERROR = 0x80000000u 1143 } 1144 1145 enum BLClipMode 1146 { 1147 BL_CLIP_MODE_ALIGNED_RECT = 0, 1148 1149 BL_CLIP_MODE_UNALIGNED_RECT = 1, 1150 1151 BL_CLIP_MODE_MASK = 2, 1152 1153 BL_CLIP_MODE_COUNT = 3 1154 } 1155 1156 enum BLCompOp 1157 { 1158 BL_COMP_OP_SRC_OVER = 0, 1159 1160 BL_COMP_OP_SRC_COPY = 1, 1161 1162 BL_COMP_OP_SRC_IN = 2, 1163 1164 BL_COMP_OP_SRC_OUT = 3, 1165 1166 BL_COMP_OP_SRC_ATOP = 4, 1167 1168 BL_COMP_OP_DST_OVER = 5, 1169 1170 BL_COMP_OP_DST_COPY = 6, 1171 1172 BL_COMP_OP_DST_IN = 7, 1173 1174 BL_COMP_OP_DST_OUT = 8, 1175 1176 BL_COMP_OP_DST_ATOP = 9, 1177 1178 BL_COMP_OP_XOR = 10, 1179 1180 BL_COMP_OP_CLEAR = 11, 1181 1182 BL_COMP_OP_PLUS = 12, 1183 1184 BL_COMP_OP_MINUS = 13, 1185 1186 BL_COMP_OP_MODULATE = 14, 1187 1188 BL_COMP_OP_MULTIPLY = 15, 1189 1190 BL_COMP_OP_SCREEN = 16, 1191 1192 BL_COMP_OP_OVERLAY = 17, 1193 1194 BL_COMP_OP_DARKEN = 18, 1195 1196 BL_COMP_OP_LIGHTEN = 19, 1197 1198 BL_COMP_OP_COLOR_DODGE = 20, 1199 1200 BL_COMP_OP_COLOR_BURN = 21, 1201 1202 BL_COMP_OP_LINEAR_BURN = 22, 1203 1204 BL_COMP_OP_LINEAR_LIGHT = 23, 1205 1206 BL_COMP_OP_PIN_LIGHT = 24, 1207 1208 BL_COMP_OP_HARD_LIGHT = 25, 1209 1210 BL_COMP_OP_SOFT_LIGHT = 26, 1211 1212 BL_COMP_OP_DIFFERENCE = 27, 1213 1214 BL_COMP_OP_EXCLUSION = 28, 1215 1216 BL_COMP_OP_COUNT = 29 1217 } 1218 1219 enum BLGradientQuality 1220 { 1221 BL_GRADIENT_QUALITY_NEAREST = 0, 1222 1223 BL_GRADIENT_QUALITY_COUNT = 1 1224 } 1225 1226 enum BLPatternQuality 1227 { 1228 BL_PATTERN_QUALITY_NEAREST = 0, 1229 1230 BL_PATTERN_QUALITY_BILINEAR = 1, 1231 1232 BL_PATTERN_QUALITY_COUNT = 2 1233 } 1234 1235 enum BLRenderingQuality 1236 { 1237 BL_RENDERING_QUALITY_ANTIALIAS = 0, 1238 1239 BL_RENDERING_QUALITY_COUNT = 1 1240 } 1241 1242 struct BLContextCreateInfo 1243 { 1244 uint flags; 1245 1246 uint threadCount; 1247 1248 uint cpuFeatures; 1249 1250 uint commandQueueLimit; 1251 1252 uint[4] reserved; 1253 } 1254 1255 struct BLContextCookie 1256 { 1257 ulong[2] data; 1258 } 1259 1260 struct BLContextHints 1261 { 1262 union 1263 { 1264 struct 1265 { 1266 ubyte renderingQuality; 1267 ubyte gradientQuality; 1268 ubyte patternQuality; 1269 } 1270 1271 ubyte[BL_CONTEXT_HINT_COUNT] hints; 1272 } 1273 } 1274 1275 struct BLContextState 1276 { 1277 BLImageCore* targetImage; 1278 1279 BLSize targetSize; 1280 1281 BLContextHints hints; 1282 1283 ubyte compOp; 1284 1285 ubyte fillRule; 1286 1287 ubyte[2] styleType; 1288 1289 ubyte[4] reserved; 1290 1291 BLApproximationOptions approximationOptions; 1292 1293 double globalAlpha; 1294 1295 double[2] styleAlpha; 1296 1297 BLStrokeOptionsCore strokeOptions; 1298 1299 BLMatrix2D metaMatrix; 1300 1301 BLMatrix2D userMatrix; 1302 1303 size_t savedStateCount; 1304 } 1305 1306 struct BLContextVirt 1307 { 1308 BLResult function(BLContextImpl* impl) destroy; 1309 BLResult function(BLContextImpl* impl, uint flags) flush; 1310 1311 BLResult function(const(BLContextImpl)* impl, uint propertyId, void* valueOut) queryProperty; 1312 1313 BLResult function(BLContextImpl* impl, BLContextCookie* cookie) save; 1314 BLResult function(BLContextImpl* impl, const(BLContextCookie)* cookie) restore; 1315 1316 BLResult function(BLContextImpl* impl, uint opType, const(void)* opData) matrixOp; 1317 BLResult function(BLContextImpl* impl) userToMeta; 1318 1319 BLResult function(BLContextImpl* impl, uint hintType, uint value) setHint; 1320 BLResult function(BLContextImpl* impl, const(BLContextHints)* hints) setHints; 1321 BLResult function(BLContextImpl* impl, uint mode) setFlattenMode; 1322 BLResult function(BLContextImpl* impl, double tolerance) setFlattenTolerance; 1323 BLResult function(BLContextImpl* impl, const(BLApproximationOptions)* options) setApproximationOptions; 1324 1325 BLResult function(BLContextImpl* impl, uint compOp) setCompOp; 1326 BLResult function(BLContextImpl* impl, double alpha) setGlobalAlpha; 1327 1328 BLResult function(BLContextImpl* impl, double alpha)[2] setStyleAlpha; 1329 BLResult function(const(BLContextImpl)* impl, BLStyleCore* out_)[2] getStyle; 1330 BLResult function(BLContextImpl* impl, const(BLStyleCore)* style)[2] setStyle; 1331 BLResult function(BLContextImpl* impl, const(BLRgba)* rgba)[2] setStyleRgba; 1332 BLResult function(BLContextImpl* impl, uint rgba32)[2] setStyleRgba32; 1333 BLResult function(BLContextImpl* impl, ulong rgba64)[2] setStyleRgba64; 1334 BLResult function(BLContextImpl* impl, const(void)* object)[2] setStyleObject; 1335 1336 BLResult function(BLContextImpl* impl, uint fillRule) setFillRule; 1337 1338 BLResult function(BLContextImpl* impl, double width) setStrokeWidth; 1339 BLResult function(BLContextImpl* impl, double miterLimit) setStrokeMiterLimit; 1340 BLResult function(BLContextImpl* impl, uint position, uint strokeCap) setStrokeCap; 1341 BLResult function(BLContextImpl* impl, uint strokeCap) setStrokeCaps; 1342 BLResult function(BLContextImpl* impl, uint strokeJoin) setStrokeJoin; 1343 BLResult function(BLContextImpl* impl, double dashOffset) setStrokeDashOffset; 1344 BLResult function(BLContextImpl* impl, const(BLArrayCore)* dashArray) setStrokeDashArray; 1345 BLResult function(BLContextImpl* impl, uint transformOrder) setStrokeTransformOrder; 1346 BLResult function(BLContextImpl* impl, const(BLStrokeOptionsCore)* options) setStrokeOptions; 1347 1348 BLResult function(BLContextImpl* impl, const(BLRectI)* rect) clipToRectI; 1349 BLResult function(BLContextImpl* impl, const(BLRect)* rect) clipToRectD; 1350 BLResult function(BLContextImpl* impl) restoreClipping; 1351 1352 BLResult function(BLContextImpl* impl) clearAll; 1353 BLResult function(BLContextImpl* impl, const(BLRectI)* rect) clearRectI; 1354 BLResult function(BLContextImpl* impl, const(BLRect)* rect) clearRectD; 1355 1356 BLResult function(BLContextImpl* impl) fillAll; 1357 BLResult function(BLContextImpl* impl, const(BLRectI)* rect) fillRectI; 1358 BLResult function(BLContextImpl* impl, const(BLRect)* rect) fillRectD; 1359 BLResult function(BLContextImpl* impl, const(BLPathCore)* path) fillPathD; 1360 BLResult function(BLContextImpl* impl, uint geometryType, const(void)* geometryData) fillGeometry; 1361 BLResult function(BLContextImpl* impl, const(BLPointI)* pt, const(BLFontCore)* font, const(void)* text, size_t size, uint encoding) fillTextI; 1362 BLResult function(BLContextImpl* impl, const(BLPoint)* pt, const(BLFontCore)* font, const(void)* text, size_t size, uint encoding) fillTextD; 1363 BLResult function(BLContextImpl* impl, const(BLPointI)* pt, const(BLFontCore)* font, const(BLGlyphRun)* glyphRun) fillGlyphRunI; 1364 BLResult function(BLContextImpl* impl, const(BLPoint)* pt, const(BLFontCore)* font, const(BLGlyphRun)* glyphRun) fillGlyphRunD; 1365 1366 BLResult function(BLContextImpl* impl, const(BLRectI)* rect) strokeRectI; 1367 BLResult function(BLContextImpl* impl, const(BLRect)* rect) strokeRectD; 1368 BLResult function(BLContextImpl* impl, const(BLPathCore)* path) strokePathD; 1369 BLResult function(BLContextImpl* impl, uint geometryType, const(void)* geometryData) strokeGeometry; 1370 BLResult function(BLContextImpl* impl, const(BLPointI)* pt, const(BLFontCore)* font, const(void)* text, size_t size, uint encoding) strokeTextI; 1371 BLResult function(BLContextImpl* impl, const(BLPoint)* pt, const(BLFontCore)* font, const(void)* text, size_t size, uint encoding) strokeTextD; 1372 BLResult function(BLContextImpl* impl, const(BLPointI)* pt, const(BLFontCore)* font, const(BLGlyphRun)* glyphRun) strokeGlyphRunI; 1373 BLResult function(BLContextImpl* impl, const(BLPoint)* pt, const(BLFontCore)* font, const(BLGlyphRun)* glyphRun) strokeGlyphRunD; 1374 1375 BLResult function(BLContextImpl* impl, const(BLPointI)* pt, const(BLImageCore)* img, const(BLRectI)* imgArea) blitImageI; 1376 BLResult function(BLContextImpl* impl, const(BLPoint)* pt, const(BLImageCore)* img, const(BLRectI)* imgArea) blitImageD; 1377 BLResult function(BLContextImpl* impl, const(BLRectI)* rect, const(BLImageCore)* img, const(BLRectI)* imgArea) blitScaledImageI; 1378 BLResult function(BLContextImpl* impl, const(BLRect)* rect, const(BLImageCore)* img, const(BLRectI)* imgArea) blitScaledImageD; 1379 } 1380 1381 struct BLContextImpl 1382 { 1383 const(BLContextVirt)* virt; 1384 1385 size_t refCount; 1386 1387 ubyte implType; 1388 1389 ubyte implTraits; 1390 1391 ushort memPoolData; 1392 1393 uint contextType; 1394 1395 const(BLContextState)* state; 1396 } 1397 1398 struct BLContextCore 1399 { 1400 BLContextImpl* impl; 1401 } 1402 1403 //****** filesystem.d ******// 1404 1405 import core.stdc.string; 1406 1407 extern (C): 1408 1409 enum BLFileOpenFlags 1410 { 1411 BL_FILE_OPEN_READ = 0x00000001u, 1412 1413 BL_FILE_OPEN_WRITE = 0x00000002u, 1414 1415 BL_FILE_OPEN_RW = 0x00000003u, 1416 1417 BL_FILE_OPEN_CREATE = 0x00000004u, 1418 1419 BL_FILE_OPEN_DELETE = 0x00000008u, 1420 1421 BL_FILE_OPEN_TRUNCATE = 0x00000010u, 1422 1423 BL_FILE_OPEN_READ_EXCLUSIVE = 0x10000000u, 1424 1425 BL_FILE_OPEN_WRITE_EXCLUSIVE = 0x20000000u, 1426 1427 BL_FILE_OPEN_RW_EXCLUSIVE = 0x30000000u, 1428 1429 BL_FILE_OPEN_CREATE_EXCLUSIVE = 0x40000000u, 1430 1431 BL_FILE_OPEN_DELETE_EXCLUSIVE = 0x80000000u 1432 } 1433 1434 enum BLFileSeekType 1435 { 1436 BL_FILE_SEEK_SET = 0, 1437 1438 BL_FILE_SEEK_CUR = 1, 1439 1440 BL_FILE_SEEK_END = 2, 1441 1442 BL_FILE_SEEK_COUNT = 3 1443 } 1444 1445 enum BLFileReadFlags 1446 { 1447 BL_FILE_READ_MMAP_ENABLED = 0x00000001u, 1448 1449 BL_FILE_READ_MMAP_AVOID_SMALL = 0x00000002u, 1450 1451 BL_FILE_READ_MMAP_NO_FALLBACK = 0x00000008u 1452 } 1453 1454 struct BLFileCore 1455 { 1456 intptr_t handle; 1457 } 1458 1459 //****** font.d ******// 1460 1461 extern (C): 1462 1463 struct BLFontDataVirt 1464 { 1465 BLResult function(BLFontDataImpl* impl) destroy; 1466 BLResult function(const(BLFontDataImpl)* impl, uint faceIndex, BLArrayCore* out_) listTags; 1467 size_t function(const(BLFontDataImpl)* impl, uint faceIndex, BLFontTable* dst, const(BLTag)* tags, size_t n) queryTables; 1468 } 1469 1470 struct BLFontDataImpl 1471 { 1472 const(BLFontDataVirt)* virt; 1473 1474 size_t refCount; 1475 1476 ubyte implType; 1477 1478 ubyte implTraits; 1479 1480 ushort memPoolData; 1481 1482 ubyte faceType; 1483 1484 ubyte[3] reserved; 1485 1486 uint faceCount; 1487 1488 uint flags; 1489 } 1490 1491 struct BLFontDataCore 1492 { 1493 BLFontDataImpl* impl; 1494 } 1495 1496 struct BLFontFaceVirt 1497 { 1498 BLResult function(BLFontFaceImpl* impl) destroy; 1499 } 1500 1501 struct BLFontFaceImpl 1502 { 1503 const(BLFontFaceVirt)* virt; 1504 1505 size_t refCount; 1506 1507 ubyte implType; 1508 1509 ubyte implTraits; 1510 1511 ushort memPoolData; 1512 1513 ushort weight; 1514 1515 ubyte stretch; 1516 1517 ubyte style; 1518 1519 BLFontFaceInfo faceInfo; 1520 1521 BLUniqueId uniqueId; 1522 1523 BLFontDataCore data; 1524 1525 BLStringCore fullName; 1526 1527 BLStringCore familyName; 1528 1529 BLStringCore subfamilyName; 1530 1531 BLStringCore postScriptName; 1532 1533 BLFontDesignMetrics designMetrics; 1534 1535 BLFontUnicodeCoverage unicodeCoverage; 1536 1537 BLFontPanose panose; 1538 } 1539 1540 struct BLFontFaceCore 1541 { 1542 BLFontFaceImpl* impl; 1543 } 1544 1545 struct BLFontImpl 1546 { 1547 BLFontFaceCore face; 1548 1549 size_t refCount; 1550 1551 ubyte implType; 1552 1553 ubyte implTraits; 1554 1555 ushort memPoolData; 1556 1557 ushort weight; 1558 1559 ubyte stretch; 1560 1561 ubyte style; 1562 1563 BLArrayCore features; 1564 1565 BLArrayCore variations; 1566 1567 BLFontMetrics metrics; 1568 1569 BLFontMatrix matrix; 1570 } 1571 1572 struct BLFontCore 1573 { 1574 BLFontImpl* impl; 1575 } 1576 1577 //****** fontdefs.d ******// 1578 1579 extern (C): 1580 1581 enum BLGlyphPlacementType 1582 { 1583 BL_GLYPH_PLACEMENT_TYPE_NONE = 0, 1584 1585 BL_GLYPH_PLACEMENT_TYPE_ADVANCE_OFFSET = 1, 1586 1587 BL_GLYPH_PLACEMENT_TYPE_DESIGN_UNITS = 2, 1588 1589 BL_GLYPH_PLACEMENT_TYPE_USER_UNITS = 3, 1590 1591 BL_GLYPH_PLACEMENT_TYPE_ABSOLUTE_UNITS = 4 1592 } 1593 1594 enum BLGlyphRunFlags 1595 { 1596 BL_GLYPH_RUN_FLAG_UCS4_CONTENT = 0x10000000u, 1597 1598 BL_GLYPH_RUN_FLAG_INVALID_TEXT = 0x20000000u, 1599 1600 BL_GLYPH_RUN_FLAG_UNDEFINED_GLYPHS = 0x40000000u, 1601 1602 BL_GLYPH_RUN_FLAG_INVALID_FONT_DATA = 0x80000000u 1603 } 1604 1605 enum BLFontDataFlags 1606 { 1607 BL_FONT_DATA_FLAG_COLLECTION = 0x00000001u 1608 } 1609 1610 enum BLFontFaceType 1611 { 1612 BL_FONT_FACE_TYPE_NONE = 0, 1613 1614 BL_FONT_FACE_TYPE_OPENTYPE = 1, 1615 1616 BL_FONT_FACE_TYPE_COUNT = 2 1617 } 1618 1619 enum BLFontFaceFlags 1620 { 1621 BL_FONT_FACE_FLAG_TYPOGRAPHIC_NAMES = 0x00000001u, 1622 1623 BL_FONT_FACE_FLAG_TYPOGRAPHIC_METRICS = 0x00000002u, 1624 1625 BL_FONT_FACE_FLAG_CHAR_TO_GLYPH_MAPPING = 0x00000004u, 1626 1627 BL_FONT_FACE_FLAG_HORIZONTAL_METIRCS = 0x00000010u, 1628 1629 BL_FONT_FACE_FLAG_VERTICAL_METRICS = 0x00000020u, 1630 1631 BL_FONT_FACE_FLAG_HORIZONTAL_KERNING = 0x00000040u, 1632 1633 BL_FONT_FACE_FLAG_VERTICAL_KERNING = 0x00000080u, 1634 1635 BL_FONT_FACE_FLAG_OPENTYPE_FEATURES = 0x00000100u, 1636 1637 BL_FONT_FACE_FLAG_PANOSE_DATA = 0x00000200u, 1638 1639 BL_FONT_FACE_FLAG_UNICODE_COVERAGE = 0x00000400u, 1640 1641 BL_FONT_FACE_FLAG_BASELINE_Y_EQUALS_0 = 0x00001000u, 1642 1643 BL_FONT_FACE_FLAG_LSB_POINT_X_EQUALS_0 = 0x00002000u, 1644 1645 BL_FONT_FACE_FLAG_VARIATION_SEQUENCES = 0x10000000u, 1646 1647 BL_FONT_FACE_FLAG_OPENTYPE_VARIATIONS = 0x20000000u, 1648 1649 BL_FONT_FACE_FLAG_SYMBOL_FONT = 0x40000000u, 1650 1651 BL_FONT_FACE_FLAG_LAST_RESORT_FONT = 0x80000000u 1652 } 1653 1654 enum BLFontFaceDiagFlags 1655 { 1656 BL_FONT_FACE_DIAG_WRONG_NAME_DATA = 0x00000001u, 1657 1658 BL_FONT_FACE_DIAG_FIXED_NAME_DATA = 0x00000002u, 1659 1660 BL_FONT_FACE_DIAG_WRONG_KERN_DATA = 0x00000004u, 1661 1662 BL_FONT_FACE_DIAG_FIXED_KERN_DATA = 0x00000008u, 1663 1664 BL_FONT_FACE_DIAG_WRONG_CMAP_DATA = 0x00000010u, 1665 1666 BL_FONT_FACE_DIAG_WRONG_CMAP_FORMAT = 0x00000020u, 1667 1668 BL_FONT_FACE_DIAG_WRONG_GDEF_DATA = 0x00000100u, 1669 1670 BL_FONT_FACE_DIAG_WRONG_GPOS_DATA = 0x00000400u, 1671 1672 BL_FONT_FACE_DIAG_WRONG_GSUB_DATA = 0x00001000u 1673 } 1674 1675 enum BLFontOutlineType 1676 { 1677 BL_FONT_OUTLINE_TYPE_NONE = 0, 1678 1679 BL_FONT_OUTLINE_TYPE_TRUETYPE = 1, 1680 1681 BL_FONT_OUTLINE_TYPE_CFF = 2, 1682 1683 BL_FONT_OUTLINE_TYPE_CFF2 = 3 1684 } 1685 1686 enum BLFontStretch 1687 { 1688 BL_FONT_STRETCH_ULTRA_CONDENSED = 1, 1689 1690 BL_FONT_STRETCH_EXTRA_CONDENSED = 2, 1691 1692 BL_FONT_STRETCH_CONDENSED = 3, 1693 1694 BL_FONT_STRETCH_SEMI_CONDENSED = 4, 1695 1696 BL_FONT_STRETCH_NORMAL = 5, 1697 1698 BL_FONT_STRETCH_SEMI_EXPANDED = 6, 1699 1700 BL_FONT_STRETCH_EXPANDED = 7, 1701 1702 BL_FONT_STRETCH_EXTRA_EXPANDED = 8, 1703 1704 BL_FONT_STRETCH_ULTRA_EXPANDED = 9 1705 } 1706 1707 enum BLFontStyle 1708 { 1709 BL_FONT_STYLE_NORMAL = 0, 1710 1711 BL_FONT_STYLE_OBLIQUE = 1, 1712 1713 BL_FONT_STYLE_ITALIC = 2, 1714 1715 BL_FONT_STYLE_COUNT = 3 1716 } 1717 1718 enum BLFontWeight 1719 { 1720 BL_FONT_WEIGHT_THIN = 100, 1721 1722 BL_FONT_WEIGHT_EXTRA_LIGHT = 200, 1723 1724 BL_FONT_WEIGHT_LIGHT = 300, 1725 1726 BL_FONT_WEIGHT_SEMI_LIGHT = 350, 1727 1728 BL_FONT_WEIGHT_NORMAL = 400, 1729 1730 BL_FONT_WEIGHT_MEDIUM = 500, 1731 1732 BL_FONT_WEIGHT_SEMI_BOLD = 600, 1733 1734 BL_FONT_WEIGHT_BOLD = 700, 1735 1736 BL_FONT_WEIGHT_EXTRA_BOLD = 800, 1737 1738 BL_FONT_WEIGHT_BLACK = 900, 1739 1740 BL_FONT_WEIGHT_EXTRA_BLACK = 950 1741 } 1742 1743 enum BLFontStringId 1744 { 1745 BL_FONT_STRING_COPYRIGHT_NOTICE = 0, 1746 1747 BL_FONT_STRING_FAMILY_NAME = 1, 1748 1749 BL_FONT_STRING_SUBFAMILY_NAME = 2, 1750 1751 BL_FONT_STRING_UNIQUE_IDENTIFIER = 3, 1752 1753 BL_FONT_STRING_FULL_NAME = 4, 1754 1755 BL_FONT_STRING_VERSION_STRING = 5, 1756 1757 BL_FONT_STRING_POST_SCRIPT_NAME = 6, 1758 1759 BL_FONT_STRING_TRADEMARK = 7, 1760 1761 BL_FONT_STRING_MANUFACTURER_NAME = 8, 1762 1763 BL_FONT_STRING_DESIGNER_NAME = 9, 1764 1765 BL_FONT_STRING_DESCRIPTION = 10, 1766 1767 BL_FONT_STRING_VENDOR_URL = 11, 1768 1769 BL_FONT_STRING_DESIGNER_URL = 12, 1770 1771 BL_FONT_STRING_LICENSE_DESCRIPTION = 13, 1772 1773 BL_FONT_STRING_LICENSE_INFO_URL = 14, 1774 1775 BL_FONT_STRING_RESERVED = 15, 1776 1777 BL_FONT_STRING_TYPOGRAPHIC_FAMILY_NAME = 16, 1778 1779 BL_FONT_STRING_TYPOGRAPHIC_SUBFAMILY_NAME = 17, 1780 1781 BL_FONT_STRING_COMPATIBLE_FULL_NAME = 18, 1782 1783 BL_FONT_STRING_SAMPLE_TEXT = 19, 1784 1785 BL_FONT_STRING_POST_SCRIPT_CID_NAME = 20, 1786 1787 BL_FONT_STRING_WWS_FAMILY_NAME = 21, 1788 1789 BL_FONT_STRING_WWS_SUBFAMILY_NAME = 22, 1790 1791 BL_FONT_STRING_LIGHT_BACKGROUND_PALETTE = 23, 1792 1793 BL_FONT_STRING_DARK_BACKGROUND_PALETTE = 24, 1794 1795 BL_FONT_STRING_VARIATIONS_POST_SCRIPT_PREFIX = 25, 1796 1797 BL_FONT_STRING_COMMON_COUNT = 26, 1798 1799 BL_FONT_STRING_CUSTOM_START_INDEX = 255 1800 } 1801 1802 enum BLFontUnicodeCoverageIndex 1803 { 1804 BL_FONT_UC_INDEX_BASIC_LATIN = 0, 1805 BL_FONT_UC_INDEX_LATIN1_SUPPLEMENT = 1, 1806 BL_FONT_UC_INDEX_LATIN_EXTENDED_A = 2, 1807 BL_FONT_UC_INDEX_LATIN_EXTENDED_B = 3, 1808 BL_FONT_UC_INDEX_IPA_EXTENSIONS = 4, 1809 1810 BL_FONT_UC_INDEX_SPACING_MODIFIER_LETTERS = 5, 1811 1812 BL_FONT_UC_INDEX_COMBINING_DIACRITICAL_MARKS = 6, 1813 BL_FONT_UC_INDEX_GREEK_AND_COPTIC = 7, 1814 BL_FONT_UC_INDEX_COPTIC = 8, 1815 BL_FONT_UC_INDEX_CYRILLIC = 9, 1816 1817 BL_FONT_UC_INDEX_ARMENIAN = 10, 1818 BL_FONT_UC_INDEX_HEBREW = 11, 1819 BL_FONT_UC_INDEX_VAI = 12, 1820 BL_FONT_UC_INDEX_ARABIC = 13, 1821 1822 BL_FONT_UC_INDEX_NKO = 14, 1823 BL_FONT_UC_INDEX_DEVANAGARI = 15, 1824 BL_FONT_UC_INDEX_BENGALI = 16, 1825 BL_FONT_UC_INDEX_GURMUKHI = 17, 1826 BL_FONT_UC_INDEX_GUJARATI = 18, 1827 BL_FONT_UC_INDEX_ORIYA = 19, 1828 BL_FONT_UC_INDEX_TAMIL = 20, 1829 BL_FONT_UC_INDEX_TELUGU = 21, 1830 BL_FONT_UC_INDEX_KANNADA = 22, 1831 BL_FONT_UC_INDEX_MALAYALAM = 23, 1832 BL_FONT_UC_INDEX_THAI = 24, 1833 BL_FONT_UC_INDEX_LAO = 25, 1834 BL_FONT_UC_INDEX_GEORGIAN = 26, 1835 1836 BL_FONT_UC_INDEX_BALINESE = 27, 1837 BL_FONT_UC_INDEX_HANGUL_JAMO = 28, 1838 BL_FONT_UC_INDEX_LATIN_EXTENDED_ADDITIONAL = 29, 1839 1840 BL_FONT_UC_INDEX_GREEK_EXTENDED = 30, 1841 BL_FONT_UC_INDEX_GENERAL_PUNCTUATION = 31, 1842 1843 BL_FONT_UC_INDEX_SUPERSCRIPTS_AND_SUBSCRIPTS = 32, 1844 BL_FONT_UC_INDEX_CURRENCY_SYMBOLS = 33, 1845 BL_FONT_UC_INDEX_COMBINING_DIACRITICAL_MARKS_FOR_SYMBOLS = 34, 1846 BL_FONT_UC_INDEX_LETTERLIKE_SYMBOLS = 35, 1847 BL_FONT_UC_INDEX_NUMBER_FORMS = 36, 1848 BL_FONT_UC_INDEX_ARROWS = 37, 1849 1850 BL_FONT_UC_INDEX_MATHEMATICAL_OPERATORS = 38, 1851 1852 BL_FONT_UC_INDEX_MISCELLANEOUS_TECHNICAL = 39, 1853 BL_FONT_UC_INDEX_CONTROL_PICTURES = 40, 1854 BL_FONT_UC_INDEX_OPTICAL_CHARACTER_RECOGNITION = 41, 1855 BL_FONT_UC_INDEX_ENCLOSED_ALPHANUMERICS = 42, 1856 BL_FONT_UC_INDEX_BOX_DRAWING = 43, 1857 BL_FONT_UC_INDEX_BLOCK_ELEMENTS = 44, 1858 BL_FONT_UC_INDEX_GEOMETRIC_SHAPES = 45, 1859 BL_FONT_UC_INDEX_MISCELLANEOUS_SYMBOLS = 46, 1860 BL_FONT_UC_INDEX_DINGBATS = 47, 1861 BL_FONT_UC_INDEX_CJK_SYMBOLS_AND_PUNCTUATION = 48, 1862 BL_FONT_UC_INDEX_HIRAGANA = 49, 1863 BL_FONT_UC_INDEX_KATAKANA = 50, 1864 1865 BL_FONT_UC_INDEX_BOPOMOFO = 51, 1866 1867 BL_FONT_UC_INDEX_HANGUL_COMPATIBILITY_JAMO = 52, 1868 BL_FONT_UC_INDEX_PHAGS_PA = 53, 1869 BL_FONT_UC_INDEX_ENCLOSED_CJK_LETTERS_AND_MONTHS = 54, 1870 BL_FONT_UC_INDEX_CJK_COMPATIBILITY = 55, 1871 BL_FONT_UC_INDEX_HANGUL_SYLLABLES = 56, 1872 BL_FONT_UC_INDEX_NON_PLANE = 57, 1873 BL_FONT_UC_INDEX_PHOENICIAN = 58, 1874 BL_FONT_UC_INDEX_CJK_UNIFIED_IDEOGRAPHS = 59, 1875 1876 BL_FONT_UC_INDEX_PRIVATE_USE_PLANE0 = 60, 1877 BL_FONT_UC_INDEX_CJK_STROKES = 61, 1878 1879 BL_FONT_UC_INDEX_ALPHABETIC_PRESENTATION_FORMS = 62, 1880 BL_FONT_UC_INDEX_ARABIC_PRESENTATION_FORMS_A = 63, 1881 BL_FONT_UC_INDEX_COMBINING_HALF_MARKS = 64, 1882 BL_FONT_UC_INDEX_VERTICAL_FORMS = 65, 1883 1884 BL_FONT_UC_INDEX_SMALL_FORM_VARIANTS = 66, 1885 BL_FONT_UC_INDEX_ARABIC_PRESENTATION_FORMS_B = 67, 1886 BL_FONT_UC_INDEX_HALFWIDTH_AND_FULLWIDTH_FORMS = 68, 1887 BL_FONT_UC_INDEX_SPECIALS = 69, 1888 BL_FONT_UC_INDEX_TIBETAN = 70, 1889 BL_FONT_UC_INDEX_SYRIAC = 71, 1890 BL_FONT_UC_INDEX_THAANA = 72, 1891 BL_FONT_UC_INDEX_SINHALA = 73, 1892 BL_FONT_UC_INDEX_MYANMAR = 74, 1893 BL_FONT_UC_INDEX_ETHIOPIC = 75, 1894 1895 BL_FONT_UC_INDEX_CHEROKEE = 76, 1896 BL_FONT_UC_INDEX_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS = 77, 1897 BL_FONT_UC_INDEX_OGHAM = 78, 1898 BL_FONT_UC_INDEX_RUNIC = 79, 1899 BL_FONT_UC_INDEX_KHMER = 80, 1900 1901 BL_FONT_UC_INDEX_MONGOLIAN = 81, 1902 BL_FONT_UC_INDEX_BRAILLE_PATTERNS = 82, 1903 BL_FONT_UC_INDEX_YI_SYLLABLES_AND_RADICALS = 83, 1904 1905 BL_FONT_UC_INDEX_TAGALOG_HANUNOO_BUHID_TAGBANWA = 84, 1906 1907 BL_FONT_UC_INDEX_OLD_ITALIC = 85, 1908 BL_FONT_UC_INDEX_GOTHIC = 86, 1909 BL_FONT_UC_INDEX_DESERET = 87, 1910 BL_FONT_UC_INDEX_MUSICAL_SYMBOLS = 88, 1911 1912 BL_FONT_UC_INDEX_MATHEMATICAL_ALPHANUMERIC_SYMBOLS = 89, 1913 BL_FONT_UC_INDEX_PRIVATE_USE_PLANE_15_16 = 90, 1914 1915 BL_FONT_UC_INDEX_VARIATION_SELECTORS = 91, 1916 1917 BL_FONT_UC_INDEX_TAGS = 92, 1918 BL_FONT_UC_INDEX_LIMBU = 93, 1919 BL_FONT_UC_INDEX_TAI_LE = 94, 1920 BL_FONT_UC_INDEX_NEW_TAI_LUE = 95, 1921 BL_FONT_UC_INDEX_BUGINESE = 96, 1922 BL_FONT_UC_INDEX_GLAGOLITIC = 97, 1923 BL_FONT_UC_INDEX_TIFINAGH = 98, 1924 BL_FONT_UC_INDEX_YIJING_HEXAGRAM_SYMBOLS = 99, 1925 BL_FONT_UC_INDEX_SYLOTI_NAGRI = 100, 1926 BL_FONT_UC_INDEX_LINEAR_B_SYLLABARY_AND_IDEOGRAMS = 101, 1927 1928 BL_FONT_UC_INDEX_ANCIENT_GREEK_NUMBERS = 102, 1929 BL_FONT_UC_INDEX_UGARITIC = 103, 1930 BL_FONT_UC_INDEX_OLD_PERSIAN = 104, 1931 BL_FONT_UC_INDEX_SHAVIAN = 105, 1932 BL_FONT_UC_INDEX_OSMANYA = 106, 1933 BL_FONT_UC_INDEX_CYPRIOT_SYLLABARY = 107, 1934 BL_FONT_UC_INDEX_KHAROSHTHI = 108, 1935 BL_FONT_UC_INDEX_TAI_XUAN_JING_SYMBOLS = 109, 1936 BL_FONT_UC_INDEX_CUNEIFORM = 110, 1937 1938 BL_FONT_UC_INDEX_COUNTING_ROD_NUMERALS = 111, 1939 BL_FONT_UC_INDEX_SUNDANESE = 112, 1940 BL_FONT_UC_INDEX_LEPCHA = 113, 1941 BL_FONT_UC_INDEX_OL_CHIKI = 114, 1942 BL_FONT_UC_INDEX_SAURASHTRA = 115, 1943 BL_FONT_UC_INDEX_KAYAH_LI = 116, 1944 BL_FONT_UC_INDEX_REJANG = 117, 1945 BL_FONT_UC_INDEX_CHAM = 118, 1946 BL_FONT_UC_INDEX_ANCIENT_SYMBOLS = 119, 1947 BL_FONT_UC_INDEX_PHAISTOS_DISC = 120, 1948 BL_FONT_UC_INDEX_CARIAN_LYCIAN_LYDIAN = 121, 1949 1950 BL_FONT_UC_INDEX_DOMINO_AND_MAHJONG_TILES = 122, 1951 1952 BL_FONT_UC_INDEX_INTERNAL_USAGE_123 = 123, 1953 BL_FONT_UC_INDEX_INTERNAL_USAGE_124 = 124, 1954 BL_FONT_UC_INDEX_INTERNAL_USAGE_125 = 125, 1955 BL_FONT_UC_INDEX_INTERNAL_USAGE_126 = 126, 1956 BL_FONT_UC_INDEX_INTERNAL_USAGE_127 = 127 1957 } 1958 1959 enum BLTextDirection 1960 { 1961 BL_TEXT_DIRECTION_LTR = 0, 1962 1963 BL_TEXT_DIRECTION_RTL = 1, 1964 1965 BL_TEXT_DIRECTION_COUNT = 2 1966 } 1967 1968 enum BLTextOrientation 1969 { 1970 BL_TEXT_ORIENTATION_HORIZONTAL = 0, 1971 1972 BL_TEXT_ORIENTATION_VERTICAL = 1, 1973 1974 BL_TEXT_ORIENTATION_COUNT = 2 1975 } 1976 1977 struct BLGlyphInfo 1978 { 1979 uint cluster; 1980 uint[2] reserved; 1981 } 1982 1983 struct BLGlyphPlacement 1984 { 1985 BLPointI placement; 1986 BLPointI advance; 1987 } 1988 1989 struct BLGlyphMappingState 1990 { 1991 size_t glyphCount; 1992 1993 size_t undefinedFirst; 1994 1995 size_t undefinedCount; 1996 } 1997 1998 struct BLGlyphOutlineSinkInfo 1999 { 2000 size_t glyphIndex; 2001 size_t contourCount; 2002 } 2003 2004 struct BLGlyphRun 2005 { 2006 void* glyphData; 2007 2008 void* placementData; 2009 2010 size_t size; 2011 2012 ubyte glyphSize; 2013 2014 ubyte placementType; 2015 2016 byte glyphAdvance; 2017 2018 byte placementAdvance; 2019 2020 uint flags; 2021 } 2022 2023 struct BLFontFaceInfo 2024 { 2025 ubyte faceType; 2026 2027 ubyte outlineType; 2028 2029 ushort glyphCount; 2030 2031 uint revision; 2032 2033 uint faceIndex; 2034 2035 uint faceFlags; 2036 2037 uint diagFlags; 2038 2039 uint[3] reserved; 2040 } 2041 2042 struct BLFontQueryProperties 2043 { 2044 uint style; 2045 2046 uint weight; 2047 2048 uint stretch; 2049 } 2050 2051 struct BLFontTable 2052 { 2053 const(ubyte)* data; 2054 2055 size_t size; 2056 } 2057 2058 struct BLFontFeature 2059 { 2060 BLTag tag; 2061 2062 uint value; 2063 } 2064 2065 struct BLFontVariation 2066 { 2067 BLTag tag; 2068 2069 float value; 2070 } 2071 2072 struct BLFontUnicodeCoverage 2073 { 2074 uint[4] data; 2075 } 2076 2077 struct BLFontPanose 2078 { 2079 union 2080 { 2081 ubyte[10] data; 2082 ubyte familyKind; 2083 2084 struct _Anonymous_0 2085 { 2086 ubyte familyKind; 2087 ubyte serifStyle; 2088 ubyte weight; 2089 ubyte proportion; 2090 ubyte contrast; 2091 ubyte strokeVariation; 2092 ubyte armStyle; 2093 ubyte letterform; 2094 ubyte midline; 2095 ubyte xHeight; 2096 } 2097 2098 _Anonymous_0 text; 2099 2100 struct _Anonymous_1 2101 { 2102 ubyte familyKind; 2103 ubyte toolKind; 2104 ubyte weight; 2105 ubyte spacing; 2106 ubyte aspectRatio; 2107 ubyte contrast; 2108 ubyte topology; 2109 ubyte form; 2110 ubyte finials; 2111 ubyte xAscent; 2112 } 2113 2114 _Anonymous_1 script; 2115 2116 struct _Anonymous_2 2117 { 2118 ubyte familyKind; 2119 ubyte decorativeClass; 2120 ubyte weight; 2121 ubyte aspect; 2122 ubyte contrast; 2123 ubyte serifVariant; 2124 ubyte treatment; 2125 ubyte lining; 2126 ubyte topology; 2127 ubyte characterRange; 2128 } 2129 2130 _Anonymous_2 decorative; 2131 2132 struct _Anonymous_3 2133 { 2134 ubyte familyKind; 2135 ubyte symbolKind; 2136 ubyte weight; 2137 ubyte spacing; 2138 ubyte aspectRatioAndContrast; 2139 ubyte aspectRatio94; 2140 ubyte aspectRatio119; 2141 ubyte aspectRatio157; 2142 ubyte aspectRatio163; 2143 ubyte aspectRatio211; 2144 } 2145 2146 _Anonymous_3 symbol; 2147 } 2148 } 2149 2150 struct BLFontMatrix 2151 { 2152 union 2153 { 2154 double[4] m; 2155 2156 struct 2157 { 2158 double m00; 2159 double m01; 2160 double m10; 2161 double m11; 2162 } 2163 } 2164 } 2165 2166 struct BLFontMetrics 2167 { 2168 float size; 2169 2170 union 2171 { 2172 struct 2173 { 2174 float ascent; 2175 2176 float vAscent; 2177 2178 float descent; 2179 2180 float vDescent; 2181 } 2182 2183 struct 2184 { 2185 float[2] ascentByOrientation; 2186 float[2] descentByOrientation; 2187 } 2188 } 2189 2190 float lineGap; 2191 2192 float xHeight; 2193 2194 float capHeight; 2195 2196 float xMin; 2197 2198 float yMin; 2199 2200 float xMax; 2201 2202 float yMax; 2203 2204 float underlinePosition; 2205 2206 float underlineThickness; 2207 2208 float strikethroughPosition; 2209 2210 float strikethroughThickness; 2211 } 2212 2213 struct BLFontDesignMetrics 2214 { 2215 int unitsPerEm; 2216 2217 int lowestPPEM; 2218 2219 int lineGap; 2220 2221 int xHeight; 2222 2223 int capHeight; 2224 2225 union 2226 { 2227 struct 2228 { 2229 int ascent; 2230 2231 int vAscent; 2232 2233 int descent; 2234 2235 int vDescent; 2236 2237 int hMinLSB; 2238 2239 int vMinLSB; 2240 2241 int hMinTSB; 2242 2243 int vMinTSB; 2244 2245 int hMaxAdvance; 2246 2247 int vMaxAdvance; 2248 } 2249 2250 struct 2251 { 2252 int[2] ascentByOrientation; 2253 2254 int[2] descentByOrientation; 2255 2256 int[2] minLSBByOrientation; 2257 2258 int[2] minTSBByOrientation; 2259 2260 int[2] maxAdvanceByOrientation; 2261 } 2262 } 2263 2264 union 2265 { 2266 BLBoxI glyphBoundingBox; 2267 2268 struct 2269 { 2270 int xMin; 2271 2272 int yMin; 2273 2274 int xMax; 2275 2276 int yMax; 2277 } 2278 } 2279 2280 int underlinePosition; 2281 2282 int underlineThickness; 2283 2284 int strikethroughPosition; 2285 2286 int strikethroughThickness; 2287 } 2288 2289 struct BLTextMetrics 2290 { 2291 BLPoint advance; 2292 BLPoint leadingBearing; 2293 BLPoint trailingBearing; 2294 BLBox boundingBox; 2295 } 2296 2297 //****** fontmanager.d ******// 2298 2299 extern (C): 2300 2301 struct BLFontManagerVirt 2302 { 2303 BLResult function(BLFontManagerImpl* impl) destroy; 2304 } 2305 2306 struct BLFontManagerImpl 2307 { 2308 const(BLFontManagerVirt)* virt; 2309 2310 size_t refCount; 2311 2312 ubyte implType; 2313 2314 ubyte implTraits; 2315 2316 ushort memPoolData; 2317 2318 ubyte[4] reserved; 2319 } 2320 2321 struct BLFontManagerCore 2322 { 2323 BLFontManagerImpl* impl; 2324 } 2325 2326 //****** format.d ******// 2327 2328 extern (C): 2329 2330 enum BLFormat 2331 { 2332 BL_FORMAT_NONE = 0, 2333 2334 BL_FORMAT_PRGB32 = 1, 2335 2336 BL_FORMAT_XRGB32 = 2, 2337 2338 BL_FORMAT_A8 = 3, 2339 2340 BL_FORMAT_COUNT = 4, 2341 2342 BL_FORMAT_RESERVED_COUNT = 16 2343 } 2344 2345 enum BLFormatFlags 2346 { 2347 BL_FORMAT_FLAG_RGB = 0x00000001u, 2348 2349 BL_FORMAT_FLAG_ALPHA = 0x00000002u, 2350 2351 BL_FORMAT_FLAG_RGBA = 0x00000003u, 2352 2353 BL_FORMAT_FLAG_LUM = 0x00000004u, 2354 2355 BL_FORMAT_FLAG_LUMA = 0x00000006u, 2356 2357 BL_FORMAT_FLAG_INDEXED = 0x00000010u, 2358 2359 BL_FORMAT_FLAG_PREMULTIPLIED = 0x00000100u, 2360 2361 BL_FORMAT_FLAG_BYTE_SWAP = 0x00000200u, 2362 2363 BL_FORMAT_FLAG_BYTE_ALIGNED = 0x00010000u, 2364 2365 BL_FORMAT_FLAG_UNDEFINED_BITS = 0x00020000u, 2366 2367 BL_FORMAT_FLAG_LE = (BL_BYTE_ORDER == 1234) ? cast(uint) 0 : cast(uint) BL_FORMAT_FLAG_BYTE_SWAP, 2368 2369 BL_FORMAT_FLAG_BE = (BL_BYTE_ORDER == 4321) ? cast(uint) 0 : cast(uint) BL_FORMAT_FLAG_BYTE_SWAP 2370 } 2371 2372 struct BLFormatInfo 2373 { 2374 uint depth; 2375 uint flags; 2376 2377 union 2378 { 2379 struct 2380 { 2381 ubyte[4] sizes; 2382 ubyte[4] shifts; 2383 } 2384 2385 struct 2386 { 2387 ubyte rSize; 2388 ubyte gSize; 2389 ubyte bSize; 2390 ubyte aSize; 2391 2392 ubyte rShift; 2393 ubyte gShift; 2394 ubyte bShift; 2395 ubyte aShift; 2396 } 2397 2398 BLRgba32* palette; 2399 } 2400 } 2401 2402 extern __gshared const(BLFormatInfo)[BL_FORMAT_RESERVED_COUNT] blFormatInfo; 2403 2404 //****** geometry.d ******// 2405 2406 extern (C): 2407 2408 enum BLGeometryDirection 2409 { 2410 BL_GEOMETRY_DIRECTION_NONE = 0, 2411 2412 BL_GEOMETRY_DIRECTION_CW = 1, 2413 2414 BL_GEOMETRY_DIRECTION_CCW = 2 2415 } 2416 2417 enum BLGeometryType 2418 { 2419 BL_GEOMETRY_TYPE_NONE = 0, 2420 2421 BL_GEOMETRY_TYPE_BOXI = 1, 2422 2423 BL_GEOMETRY_TYPE_BOXD = 2, 2424 2425 BL_GEOMETRY_TYPE_RECTI = 3, 2426 2427 BL_GEOMETRY_TYPE_RECTD = 4, 2428 2429 BL_GEOMETRY_TYPE_CIRCLE = 5, 2430 2431 BL_GEOMETRY_TYPE_ELLIPSE = 6, 2432 2433 BL_GEOMETRY_TYPE_ROUND_RECT = 7, 2434 2435 BL_GEOMETRY_TYPE_ARC = 8, 2436 2437 BL_GEOMETRY_TYPE_CHORD = 9, 2438 2439 BL_GEOMETRY_TYPE_PIE = 10, 2440 2441 BL_GEOMETRY_TYPE_LINE = 11, 2442 2443 BL_GEOMETRY_TYPE_TRIANGLE = 12, 2444 2445 BL_GEOMETRY_TYPE_POLYLINEI = 13, 2446 2447 BL_GEOMETRY_TYPE_POLYLINED = 14, 2448 2449 BL_GEOMETRY_TYPE_POLYGONI = 15, 2450 2451 BL_GEOMETRY_TYPE_POLYGOND = 16, 2452 2453 BL_GEOMETRY_TYPE_ARRAY_VIEW_BOXI = 17, 2454 2455 BL_GEOMETRY_TYPE_ARRAY_VIEW_BOXD = 18, 2456 2457 BL_GEOMETRY_TYPE_ARRAY_VIEW_RECTI = 19, 2458 2459 BL_GEOMETRY_TYPE_ARRAY_VIEW_RECTD = 20, 2460 2461 BL_GEOMETRY_TYPE_PATH = 21, 2462 2463 BL_GEOMETRY_TYPE_REGION = 22, 2464 2465 BL_GEOMETRY_TYPE_COUNT = 23, 2466 2467 BL_GEOMETRY_TYPE_SIMPLE_LAST = BL_GEOMETRY_TYPE_TRIANGLE 2468 } 2469 2470 enum BLFillRule 2471 { 2472 BL_FILL_RULE_NON_ZERO = 0, 2473 2474 BL_FILL_RULE_EVEN_ODD = 1, 2475 2476 BL_FILL_RULE_COUNT = 2 2477 } 2478 2479 enum BLHitTest 2480 { 2481 BL_HIT_TEST_IN = 0, 2482 2483 BL_HIT_TEST_PART = 1, 2484 2485 BL_HIT_TEST_OUT = 2, 2486 2487 BL_HIT_TEST_INVALID = 0xFFFFFFFFu 2488 } 2489 2490 struct BLPointI 2491 { 2492 int x; 2493 int y; 2494 } 2495 2496 struct BLSizeI 2497 { 2498 int w; 2499 int h; 2500 } 2501 2502 struct BLBoxI 2503 { 2504 int x0; 2505 int y0; 2506 int x1; 2507 int y1; 2508 } 2509 2510 struct BLRectI 2511 { 2512 int x; 2513 int y; 2514 int w; 2515 int h; 2516 } 2517 2518 struct BLPoint 2519 { 2520 double x; 2521 double y; 2522 } 2523 2524 struct BLSize 2525 { 2526 double w; 2527 double h; 2528 } 2529 2530 struct BLBox 2531 { 2532 double x0; 2533 double y0; 2534 double x1; 2535 double y1; 2536 } 2537 2538 struct BLRect 2539 { 2540 double x; 2541 double y; 2542 double w; 2543 double h; 2544 } 2545 2546 struct BLLine 2547 { 2548 double x0; 2549 double y0; 2550 double x1; 2551 double y1; 2552 } 2553 2554 struct BLTriangle 2555 { 2556 double x0; 2557 double y0; 2558 double x1; 2559 double y1; 2560 double x2; 2561 double y2; 2562 } 2563 2564 struct BLRoundRect 2565 { 2566 double x; 2567 double y; 2568 double w; 2569 double h; 2570 double rx; 2571 double ry; 2572 } 2573 2574 struct BLCircle 2575 { 2576 double cx; 2577 double cy; 2578 double r; 2579 } 2580 2581 struct BLEllipse 2582 { 2583 double cx; 2584 double cy; 2585 double rx; 2586 double ry; 2587 } 2588 2589 struct BLArc 2590 { 2591 double cx; 2592 double cy; 2593 double rx; 2594 double ry; 2595 double start; 2596 double sweep; 2597 } 2598 2599 //****** glyphbuffer.d ******// 2600 2601 extern (C): 2602 2603 struct BLGlyphBufferImpl 2604 { 2605 union 2606 { 2607 struct 2608 { 2609 uint* content; 2610 2611 BLGlyphPlacement* placementData; 2612 2613 size_t size; 2614 2615 uint reserved; 2616 2617 uint flags; 2618 } 2619 2620 BLGlyphRun glyphRun; 2621 } 2622 2623 BLGlyphInfo* infoData; 2624 } 2625 2626 struct BLGlyphBufferCore 2627 { 2628 BLGlyphBufferImpl* impl; 2629 } 2630 2631 //****** gradient.d ******// 2632 2633 extern (C): 2634 2635 enum BLGradientType 2636 { 2637 BL_GRADIENT_TYPE_LINEAR = 0, 2638 2639 BL_GRADIENT_TYPE_RADIAL = 1, 2640 2641 BL_GRADIENT_TYPE_CONICAL = 2, 2642 2643 BL_GRADIENT_TYPE_COUNT = 3 2644 } 2645 2646 enum BLGradientValue 2647 { 2648 BL_GRADIENT_VALUE_COMMON_X0 = 0, 2649 2650 BL_GRADIENT_VALUE_COMMON_Y0 = 1, 2651 2652 BL_GRADIENT_VALUE_COMMON_X1 = 2, 2653 2654 BL_GRADIENT_VALUE_COMMON_Y1 = 3, 2655 2656 BL_GRADIENT_VALUE_RADIAL_R0 = 4, 2657 2658 BL_GRADIENT_VALUE_CONICAL_ANGLE = 2, 2659 2660 BL_GRADIENT_VALUE_COUNT = 6 2661 } 2662 2663 struct BLGradientStop 2664 { 2665 double offset; 2666 BLRgba64 rgba; 2667 } 2668 2669 struct BLLinearGradientValues 2670 { 2671 double x0; 2672 double y0; 2673 double x1; 2674 double y1; 2675 } 2676 2677 struct BLRadialGradientValues 2678 { 2679 double x0; 2680 double y0; 2681 double x1; 2682 double y1; 2683 double r0; 2684 } 2685 2686 struct BLConicalGradientValues 2687 { 2688 double x0; 2689 double y0; 2690 double angle; 2691 } 2692 2693 struct BLGradientImpl 2694 { 2695 size_t capacity; 2696 2697 size_t refCount; 2698 2699 ubyte implType; 2700 2701 ubyte implTraits; 2702 2703 ushort memPoolData; 2704 2705 ubyte gradientType; 2706 2707 ubyte extendMode; 2708 2709 ubyte matrixType; 2710 2711 ubyte[1] reserved; 2712 2713 union 2714 { 2715 struct 2716 { 2717 BLGradientStop* stops; 2718 2719 size_t size; 2720 } 2721 } 2722 2723 BLMatrix2D matrix; 2724 2725 union 2726 { 2727 double[BL_GRADIENT_VALUE_COUNT] values; 2728 2729 BLLinearGradientValues linear; 2730 2731 BLRadialGradientValues radial; 2732 2733 BLConicalGradientValues conical; 2734 } 2735 } 2736 2737 struct BLGradientCore 2738 { 2739 BLGradientImpl* impl; 2740 } 2741 2742 //****** image.d ******// 2743 2744 import core.stdc.string; 2745 2746 extern (C): 2747 2748 enum BLImageInfoFlags 2749 { 2750 BL_IMAGE_INFO_FLAG_PROGRESSIVE = 0x00000001u 2751 } 2752 2753 enum BLImageScaleFilter 2754 { 2755 BL_IMAGE_SCALE_FILTER_NONE = 0, 2756 2757 BL_IMAGE_SCALE_FILTER_NEAREST = 1, 2758 2759 BL_IMAGE_SCALE_FILTER_BILINEAR = 2, 2760 2761 BL_IMAGE_SCALE_FILTER_BICUBIC = 3, 2762 2763 BL_IMAGE_SCALE_FILTER_BELL = 4, 2764 2765 BL_IMAGE_SCALE_FILTER_GAUSS = 5, 2766 2767 BL_IMAGE_SCALE_FILTER_HERMITE = 6, 2768 2769 BL_IMAGE_SCALE_FILTER_HANNING = 7, 2770 2771 BL_IMAGE_SCALE_FILTER_CATROM = 8, 2772 2773 BL_IMAGE_SCALE_FILTER_BESSEL = 9, 2774 2775 BL_IMAGE_SCALE_FILTER_SINC = 10, 2776 2777 BL_IMAGE_SCALE_FILTER_LANCZOS = 11, 2778 2779 BL_IMAGE_SCALE_FILTER_BLACKMAN = 12, 2780 2781 BL_IMAGE_SCALE_FILTER_MITCHELL = 13, 2782 2783 BL_IMAGE_SCALE_FILTER_USER = 14, 2784 2785 BL_IMAGE_SCALE_FILTER_COUNT = 15 2786 } 2787 2788 alias BLImageScaleUserFunc = uint function(double* dst, const(double)* tArray, size_t n, const(void)* data); 2789 2790 struct BLImageData 2791 { 2792 void* pixelData; 2793 intptr_t stride; 2794 BLSizeI size; 2795 uint format; 2796 uint flags; 2797 } 2798 2799 struct BLImageInfo 2800 { 2801 BLSizeI size; 2802 2803 BLSize density; 2804 2805 uint flags; 2806 2807 ushort depth; 2808 2809 ushort planeCount; 2810 2811 ulong frameCount; 2812 2813 char[16] format; 2814 2815 char[16] compression; 2816 } 2817 2818 struct BLImageScaleOptions 2819 { 2820 BLImageScaleUserFunc userFunc; 2821 void* userData; 2822 2823 double radius; 2824 2825 union 2826 { 2827 double[3] data; 2828 2829 struct _Anonymous_0 2830 { 2831 double b; 2832 double c; 2833 } 2834 2835 _Anonymous_0 mitchell; 2836 } 2837 } 2838 2839 struct BLImageImpl 2840 { 2841 void* pixelData; 2842 2843 size_t refCount; 2844 2845 ubyte implType; 2846 2847 ubyte implTraits; 2848 2849 ushort memPoolData; 2850 2851 ubyte format; 2852 2853 ubyte flags; 2854 2855 ushort depth; 2856 2857 BLSizeI size; 2858 2859 intptr_t stride; 2860 } 2861 2862 struct BLImageCore 2863 { 2864 BLImageImpl* impl; 2865 } 2866 2867 //****** imagecodec.d ******// 2868 2869 extern (C): 2870 2871 enum BLImageCodecFeatures 2872 { 2873 BL_IMAGE_CODEC_FEATURE_READ = 0x00000001u, 2874 2875 BL_IMAGE_CODEC_FEATURE_WRITE = 0x00000002u, 2876 2877 BL_IMAGE_CODEC_FEATURE_LOSSLESS = 0x00000004u, 2878 2879 BL_IMAGE_CODEC_FEATURE_LOSSY = 0x00000008u, 2880 2881 BL_IMAGE_CODEC_FEATURE_MULTI_FRAME = 0x00000010u, 2882 2883 BL_IMAGE_CODEC_FEATURE_IPTC = 0x10000000u, 2884 2885 BL_IMAGE_CODEC_FEATURE_EXIF = 0x20000000u, 2886 2887 BL_IMAGE_CODEC_FEATURE_XMP = 0x40000000u 2888 } 2889 2890 struct BLImageCodecVirt 2891 { 2892 BLResult function(BLImageCodecImpl* impl) destroy; 2893 uint function(const(BLImageCodecImpl)* impl, const(ubyte)* data, size_t size) inspectData; 2894 BLResult function(const(BLImageCodecImpl)* impl, BLImageDecoderCore* dst) createDecoder; 2895 BLResult function(const(BLImageCodecImpl)* impl, BLImageEncoderCore* dst) createEncoder; 2896 } 2897 2898 struct BLImageCodecImpl 2899 { 2900 const(BLImageCodecVirt)* virt; 2901 2902 size_t refCount; 2903 2904 ubyte implType; 2905 2906 ubyte implTraits; 2907 2908 ushort memPoolData; 2909 2910 uint features; 2911 2912 const(char)* name; 2913 2914 const(char)* vendor; 2915 2916 const(char)* mimeType; 2917 2918 const(char)* extensions; 2919 } 2920 2921 struct BLImageCodecCore 2922 { 2923 BLImageCodecImpl* impl; 2924 } 2925 2926 struct BLImageDecoderVirt 2927 { 2928 BLResult function(BLImageDecoderImpl* impl) destroy; 2929 BLResult function(BLImageDecoderImpl* impl) restart; 2930 BLResult function(BLImageDecoderImpl* impl, BLImageInfo* infoOut, const(ubyte)* data, size_t size) readInfo; 2931 BLResult function(BLImageDecoderImpl* impl, BLImageCore* imageOut, const(ubyte)* data, size_t size) readFrame; 2932 } 2933 2934 struct BLImageDecoderImpl 2935 { 2936 const(BLImageDecoderVirt)* virt; 2937 2938 size_t refCount; 2939 2940 ubyte implType; 2941 2942 ubyte implTraits; 2943 2944 ushort memPoolData; 2945 2946 BLResult lastResult; 2947 2948 BLImageCodecCore codec; 2949 2950 void* handle; 2951 2952 ulong frameIndex; 2953 2954 size_t bufferIndex; 2955 } 2956 2957 struct BLImageDecoderCore 2958 { 2959 BLImageDecoderImpl* impl; 2960 } 2961 2962 struct BLImageEncoderVirt 2963 { 2964 BLResult function(BLImageEncoderImpl* impl) destroy; 2965 BLResult function(BLImageEncoderImpl* impl) restart; 2966 BLResult function(BLImageEncoderImpl* impl, BLArrayCore* dst, const(BLImageCore)* image) writeFrame; 2967 } 2968 2969 struct BLImageEncoderImpl 2970 { 2971 const(BLImageEncoderVirt)* virt; 2972 2973 size_t refCount; 2974 2975 ubyte implType; 2976 2977 ubyte implTraits; 2978 2979 ushort memPoolData; 2980 2981 BLResult lastResult; 2982 2983 BLImageCodecCore codec; 2984 2985 void* handle; 2986 2987 ulong frameIndex; 2988 2989 size_t bufferIndex; 2990 } 2991 2992 struct BLImageEncoderCore 2993 { 2994 BLImageEncoderImpl* impl; 2995 } 2996 2997 //****** matrix.d ******// 2998 2999 extern (C): 3000 3001 alias BLMapPointDArrayFunc = uint function(const(void)* ctx, BLPoint* dst, const(BLPoint)* src, size_t count); 3002 3003 enum BLMatrix2DType 3004 { 3005 BL_MATRIX2D_TYPE_IDENTITY = 0, 3006 3007 BL_MATRIX2D_TYPE_TRANSLATE = 1, 3008 3009 BL_MATRIX2D_TYPE_SCALE = 2, 3010 3011 BL_MATRIX2D_TYPE_SWAP = 3, 3012 3013 BL_MATRIX2D_TYPE_AFFINE = 4, 3014 3015 BL_MATRIX2D_TYPE_INVALID = 5, 3016 3017 BL_MATRIX2D_TYPE_COUNT = 6 3018 } 3019 3020 enum BLMatrix2DValue 3021 { 3022 BL_MATRIX2D_VALUE_00 = 0, 3023 3024 BL_MATRIX2D_VALUE_01 = 1, 3025 3026 BL_MATRIX2D_VALUE_10 = 2, 3027 3028 BL_MATRIX2D_VALUE_11 = 3, 3029 3030 BL_MATRIX2D_VALUE_20 = 4, 3031 3032 BL_MATRIX2D_VALUE_21 = 5, 3033 3034 BL_MATRIX2D_VALUE_COUNT = 6 3035 } 3036 3037 enum BLMatrix2DOp 3038 { 3039 BL_MATRIX2D_OP_RESET = 0, 3040 3041 BL_MATRIX2D_OP_ASSIGN = 1, 3042 3043 BL_MATRIX2D_OP_TRANSLATE = 2, 3044 3045 BL_MATRIX2D_OP_SCALE = 3, 3046 3047 BL_MATRIX2D_OP_SKEW = 4, 3048 3049 BL_MATRIX2D_OP_ROTATE = 5, 3050 3051 BL_MATRIX2D_OP_ROTATE_PT = 6, 3052 3053 BL_MATRIX2D_OP_TRANSFORM = 7, 3054 3055 BL_MATRIX2D_OP_POST_TRANSLATE = 8, 3056 3057 BL_MATRIX2D_OP_POST_SCALE = 9, 3058 3059 BL_MATRIX2D_OP_POST_SKEW = 10, 3060 3061 BL_MATRIX2D_OP_POST_ROTATE = 11, 3062 3063 BL_MATRIX2D_OP_POST_ROTATE_PT = 12, 3064 3065 BL_MATRIX2D_OP_POST_TRANSFORM = 13, 3066 3067 BL_MATRIX2D_OP_COUNT = 14 3068 } 3069 3070 struct BLMatrix2D 3071 { 3072 union 3073 { 3074 double[BL_MATRIX2D_VALUE_COUNT] m; 3075 3076 struct 3077 { 3078 double m00; 3079 double m01; 3080 double m10; 3081 double m11; 3082 double m20; 3083 double m21; 3084 } 3085 } 3086 } 3087 3088 extern __gshared BLMapPointDArrayFunc[BL_MATRIX2D_TYPE_COUNT] blMatrix2DMapPointDArrayFuncs; 3089 3090 3091 //****** path.d ******// 3092 3093 extern (C): 3094 3095 enum BLPathCmd 3096 { 3097 BL_PATH_CMD_MOVE = 0, 3098 3099 BL_PATH_CMD_ON = 1, 3100 3101 BL_PATH_CMD_QUAD = 2, 3102 3103 BL_PATH_CMD_CUBIC = 3, 3104 3105 BL_PATH_CMD_CLOSE = 4, 3106 3107 BL_PATH_CMD_COUNT = 5 3108 } 3109 3110 enum BLPathCmdExtra 3111 { 3112 BL_PATH_CMD_PRESERVE = 0xFFFFFFFFu 3113 } 3114 3115 enum BLPathFlags 3116 { 3117 BL_PATH_FLAG_EMPTY = 0x00000001u, 3118 3119 BL_PATH_FLAG_MULTIPLE = 0x00000002u, 3120 3121 BL_PATH_FLAG_QUADS = 0x00000004u, 3122 3123 BL_PATH_FLAG_CUBICS = 0x00000008u, 3124 3125 BL_PATH_FLAG_INVALID = 0x40000000u, 3126 3127 BL_PATH_FLAG_DIRTY = 0x80000000u 3128 } 3129 3130 enum BLPathReverseMode 3131 { 3132 BL_PATH_REVERSE_MODE_COMPLETE = 0, 3133 3134 BL_PATH_REVERSE_MODE_SEPARATE = 1, 3135 3136 BL_PATH_REVERSE_MODE_COUNT = 2 3137 } 3138 3139 enum BLStrokeJoin 3140 { 3141 BL_STROKE_JOIN_MITER_CLIP = 0, 3142 3143 BL_STROKE_JOIN_MITER_BEVEL = 1, 3144 3145 BL_STROKE_JOIN_MITER_ROUND = 2, 3146 3147 BL_STROKE_JOIN_BEVEL = 3, 3148 3149 BL_STROKE_JOIN_ROUND = 4, 3150 3151 BL_STROKE_JOIN_COUNT = 5 3152 } 3153 3154 enum BLStrokeCapPosition 3155 { 3156 BL_STROKE_CAP_POSITION_START = 0, 3157 3158 BL_STROKE_CAP_POSITION_END = 1, 3159 3160 BL_STROKE_CAP_POSITION_COUNT = 2 3161 } 3162 3163 enum BLStrokeCap 3164 { 3165 BL_STROKE_CAP_BUTT = 0, 3166 3167 BL_STROKE_CAP_SQUARE = 1, 3168 3169 BL_STROKE_CAP_ROUND = 2, 3170 3171 BL_STROKE_CAP_ROUND_REV = 3, 3172 3173 BL_STROKE_CAP_TRIANGLE = 4, 3174 3175 BL_STROKE_CAP_TRIANGLE_REV = 5, 3176 3177 BL_STROKE_CAP_COUNT = 6 3178 } 3179 3180 enum BLStrokeTransformOrder 3181 { 3182 BL_STROKE_TRANSFORM_ORDER_AFTER = 0, 3183 3184 BL_STROKE_TRANSFORM_ORDER_BEFORE = 1, 3185 3186 BL_STROKE_TRANSFORM_ORDER_COUNT = 2 3187 } 3188 3189 enum BLFlattenMode 3190 { 3191 BL_FLATTEN_MODE_DEFAULT = 0, 3192 3193 BL_FLATTEN_MODE_RECURSIVE = 1, 3194 3195 BL_FLATTEN_MODE_COUNT = 2 3196 } 3197 3198 enum BLOffsetMode 3199 { 3200 BL_OFFSET_MODE_DEFAULT = 0, 3201 3202 BL_OFFSET_MODE_ITERATIVE = 1, 3203 3204 BL_OFFSET_MODE_COUNT = 2 3205 } 3206 3207 struct BLApproximationOptions 3208 { 3209 ubyte flattenMode; 3210 3211 ubyte offsetMode; 3212 3213 ubyte[6] reservedFlags; 3214 3215 double flattenTolerance; 3216 3217 double simplifyTolerance; 3218 3219 double offsetParameter; 3220 } 3221 3222 extern __gshared const BLApproximationOptions blDefaultApproximationOptions; 3223 3224 struct BLStrokeOptionsCore 3225 { 3226 union 3227 { 3228 struct 3229 { 3230 ubyte startCap; 3231 ubyte endCap; 3232 ubyte join; 3233 ubyte transformOrder; 3234 ubyte[4] reserved; 3235 } 3236 3237 ubyte[BL_STROKE_CAP_POSITION_COUNT] caps; 3238 ulong hints; 3239 } 3240 3241 double width; 3242 double miterLimit; 3243 double dashOffset; 3244 BLArrayCore dashArray; 3245 } 3246 3247 struct BLPathView 3248 { 3249 const(ubyte)* commandData; 3250 const(BLPoint)* vertexData; 3251 size_t size; 3252 } 3253 3254 struct BLPathImpl 3255 { 3256 size_t capacity; 3257 3258 size_t refCount; 3259 3260 ubyte implType; 3261 3262 ubyte implTraits; 3263 3264 ushort memPoolData; 3265 3266 uint flags; 3267 3268 union 3269 { 3270 struct 3271 { 3272 ubyte* commandData; 3273 3274 BLPoint* vertexData; 3275 3276 size_t size; 3277 } 3278 3279 BLPathView view; 3280 } 3281 } 3282 3283 struct BLPathCore 3284 { 3285 BLPathImpl* impl; 3286 } 3287 3288 //****** pattern.d ******// 3289 3290 extern (C): 3291 3292 struct BLPatternImpl 3293 { 3294 BLImageCore image; 3295 3296 size_t refCount; 3297 3298 ubyte implType; 3299 3300 ubyte implTraits; 3301 3302 ushort memPoolData; 3303 3304 ubyte patternType; 3305 3306 ubyte extendMode; 3307 3308 ubyte matrixType; 3309 3310 ubyte[1] reserved; 3311 3312 BLMatrix2D matrix; 3313 3314 BLRectI area; 3315 } 3316 3317 struct BLPatternCore 3318 { 3319 BLPatternImpl* impl; 3320 } 3321 3322 //****** pixelconverter.d ******// 3323 3324 import core.stdc.string; 3325 3326 extern (C): 3327 3328 alias BLPixelConverterFunc = uint function(const(BLPixelConverterCore)* self, ubyte* dstData, intptr_t dstStride, const(ubyte)* srcData, intptr_t srcStride, uint w, uint h, const(BLPixelConverterOptions)* options); 3329 3330 enum BLPixelConverterCreateFlags 3331 { 3332 BL_PIXEL_CONVERTER_CREATE_FLAG_DONT_COPY_PALETTE = 0x00000001u, 3333 3334 BL_PIXEL_CONVERTER_CREATE_FLAG_ALTERABLE_PALETTE = 0x00000002u, 3335 3336 BL_PIXEL_CONVERTER_CREATE_FLAG_NO_MULTI_STEP = 0x00000004u 3337 } 3338 3339 struct BLPixelConverterOptions 3340 { 3341 BLPointI origin; 3342 size_t gap; 3343 } 3344 3345 struct BLPixelConverterCore 3346 { 3347 union 3348 { 3349 struct 3350 { 3351 BLPixelConverterFunc convertFunc; 3352 3353 ubyte internalFlags; 3354 } 3355 3356 ubyte[80] data; 3357 } 3358 } 3359 3360 //****** random.d ******// 3361 3362 extern (C): 3363 3364 struct BLRandom 3365 { 3366 ulong[2] data; 3367 } 3368 3369 //****** region.d ******// 3370 3371 extern (C): 3372 3373 enum BLRegionType 3374 { 3375 BL_REGION_TYPE_EMPTY = 0, 3376 3377 BL_REGION_TYPE_RECT = 1, 3378 3379 BL_REGION_TYPE_COMPLEX = 2, 3380 3381 BL_REGION_TYPE_COUNT = 3 3382 } 3383 3384 struct BLRegionImpl 3385 { 3386 size_t capacity; 3387 3388 size_t refCount; 3389 3390 ubyte implType; 3391 3392 ubyte implTraits; 3393 3394 ushort memPoolData; 3395 3396 ubyte[4] reserved; 3397 3398 union 3399 { 3400 struct 3401 { 3402 BLBoxI* data; 3403 3404 size_t size; 3405 } 3406 3407 BLRegionView view; 3408 } 3409 3410 BLBoxI boundingBox; 3411 } 3412 3413 struct BLRegionCore 3414 { 3415 BLRegionImpl* impl; 3416 } 3417 3418 //****** rgba.d ******// 3419 3420 extern (C): 3421 3422 struct BLRgba32 3423 { 3424 union 3425 { 3426 uint value; 3427 3428 struct 3429 { 3430 import std.bitmanip : bitfields; 3431 3432 mixin(bitfields!( 3433 uint, "b", 8, 3434 uint, "g", 8, 3435 uint, "r", 8, 3436 uint, "a", 8)); 3437 } 3438 } 3439 } 3440 3441 struct BLRgba64 3442 { 3443 union 3444 { 3445 ulong value; 3446 3447 struct 3448 { 3449 import std.bitmanip : bitfields; 3450 3451 mixin(bitfields!( 3452 uint, "b", 16, 3453 uint, "g", 16, 3454 uint, "r", 16, 3455 uint, "a", 16)); 3456 } 3457 } 3458 } 3459 3460 struct BLRgba 3461 { 3462 float r; 3463 float g; 3464 float b; 3465 float a; 3466 } 3467 3468 //****** runtime.d ******// 3469 3470 extern (C): 3471 3472 enum BLRuntimeLimits 3473 { 3474 BL_RUNTIME_MAX_IMAGE_SIZE = 65535, 3475 3476 BL_RUNTIME_MAX_THREAD_COUNT = 32 3477 } 3478 3479 enum BLRuntimeInfoType 3480 { 3481 BL_RUNTIME_INFO_TYPE_BUILD = 0, 3482 3483 BL_RUNTIME_INFO_TYPE_SYSTEM = 1, 3484 3485 BL_RUNTIME_INFO_TYPE_RESOURCE = 2, 3486 3487 BL_RUNTIME_INFO_TYPE_COUNT = 3 3488 } 3489 3490 enum BLRuntimeBuildType 3491 { 3492 BL_RUNTIME_BUILD_TYPE_DEBUG = 0, 3493 3494 BL_RUNTIME_BUILD_TYPE_RELEASE = 1 3495 } 3496 3497 enum BLRuntimeCpuArch 3498 { 3499 BL_RUNTIME_CPU_ARCH_UNKNOWN = 0, 3500 3501 BL_RUNTIME_CPU_ARCH_X86 = 1, 3502 3503 BL_RUNTIME_CPU_ARCH_ARM = 2, 3504 3505 BL_RUNTIME_CPU_ARCH_MIPS = 3 3506 } 3507 3508 enum BLRuntimeCpuFeatures 3509 { 3510 BL_RUNTIME_CPU_FEATURE_X86_SSE2 = 0x00000001u, 3511 BL_RUNTIME_CPU_FEATURE_X86_SSE3 = 0x00000002u, 3512 BL_RUNTIME_CPU_FEATURE_X86_SSSE3 = 0x00000004u, 3513 BL_RUNTIME_CPU_FEATURE_X86_SSE4_1 = 0x00000008u, 3514 BL_RUNTIME_CPU_FEATURE_X86_SSE4_2 = 0x00000010u, 3515 BL_RUNTIME_CPU_FEATURE_X86_AVX = 0x00000020u, 3516 BL_RUNTIME_CPU_FEATURE_X86_AVX2 = 0x00000040u 3517 } 3518 3519 enum BLRuntimeCleanupFlags 3520 { 3521 BL_RUNTIME_CLEANUP_OBJECT_POOL = 0x00000001u, 3522 3523 BL_RUNTIME_CLEANUP_ZEROED_POOL = 0x00000002u, 3524 3525 BL_RUNTIME_CLEANUP_THREAD_POOL = 0x00000010u, 3526 3527 BL_RUNTIME_CLEANUP_EVERYTHING = 0xFFFFFFFFu 3528 } 3529 3530 struct BLRuntimeBuildInfo 3531 { 3532 union 3533 { 3534 uint version_; 3535 3536 struct 3537 { 3538 ubyte patchVersion; 3539 ubyte minorVersion; 3540 ushort majorVersion; 3541 } 3542 } 3543 3544 uint buildType; 3545 3546 uint baselineCpuFeatures; 3547 3548 uint supportedCpuFeatures; 3549 3550 uint maxImageSize; 3551 3552 uint maxThreadCount; 3553 3554 uint[2] reserved; 3555 3556 char[32] compilerInfo; 3557 } 3558 3559 struct BLRuntimeSystemInfo 3560 { 3561 uint cpuArch; 3562 3563 uint cpuFeatures; 3564 3565 uint coreCount; 3566 3567 uint threadCount; 3568 3569 uint threadStackSize; 3570 3571 uint removed; 3572 3573 uint allocationGranularity; 3574 3575 uint[5] reserved; 3576 } 3577 3578 struct BLRuntimeResourceInfo 3579 { 3580 size_t vmUsed; 3581 3582 size_t vmReserved; 3583 3584 size_t vmOverhead; 3585 3586 size_t vmBlockCount; 3587 3588 size_t zmUsed; 3589 3590 size_t zmReserved; 3591 3592 size_t zmOverhead; 3593 3594 size_t zmBlockCount; 3595 3596 size_t dynamicPipelineCount; 3597 3598 size_t fileHandleCount; 3599 3600 size_t fileMappingCount; 3601 3602 size_t[5] reserved; 3603 } 3604 3605 //****** string.d ******// 3606 3607 extern (C): 3608 3609 struct BLStringImpl 3610 { 3611 size_t capacity; 3612 3613 size_t refCount; 3614 3615 ubyte implType; 3616 3617 ubyte implTraits; 3618 3619 ushort memPoolData; 3620 3621 uint reserved; 3622 3623 union 3624 { 3625 struct 3626 { 3627 char* data; 3628 3629 size_t size; 3630 } 3631 3632 BLStringView view; 3633 } 3634 } 3635 3636 struct BLStringCore 3637 { 3638 BLStringImpl* impl; 3639 } 3640 3641 //****** style.d ******// 3642 3643 extern (C): 3644 3645 enum BLStyleType 3646 { 3647 BL_STYLE_TYPE_NONE = 0, 3648 3649 BL_STYLE_TYPE_SOLID = 1, 3650 3651 BL_STYLE_TYPE_PATTERN = 2, 3652 3653 BL_STYLE_TYPE_GRADIENT = 3, 3654 3655 BL_STYLE_TYPE_COUNT = 4 3656 } 3657 3658 struct BLStyleCore 3659 { 3660 union 3661 { 3662 BLRgba rgba; 3663 3664 BLVariantCore variant; 3665 3666 BLPatternCore pattern; 3667 3668 BLGradientCore gradient; 3669 3670 struct _Anonymous_0 3671 { 3672 ulong unknown; 3673 uint type; 3674 uint tag; 3675 } 3676 3677 _Anonymous_0 data; 3678 3679 ulong[2] u64Data; 3680 } 3681 } 3682 3683 //****** variant.d ******// 3684 3685 import core.stdc.string; 3686 3687 extern (C): 3688 3689 enum BLImplType 3690 { 3691 BL_IMPL_TYPE_NULL = 0, 3692 3693 BL_IMPL_TYPE_ARRAY_VAR = 1, 3694 3695 BL_IMPL_TYPE_ARRAY_I8 = 2, 3696 3697 BL_IMPL_TYPE_ARRAY_U8 = 3, 3698 3699 BL_IMPL_TYPE_ARRAY_I16 = 4, 3700 3701 BL_IMPL_TYPE_ARRAY_U16 = 5, 3702 3703 BL_IMPL_TYPE_ARRAY_I32 = 6, 3704 3705 BL_IMPL_TYPE_ARRAY_U32 = 7, 3706 3707 BL_IMPL_TYPE_ARRAY_I64 = 8, 3708 3709 BL_IMPL_TYPE_ARRAY_U64 = 9, 3710 3711 BL_IMPL_TYPE_ARRAY_F32 = 10, 3712 3713 BL_IMPL_TYPE_ARRAY_F64 = 11, 3714 3715 BL_IMPL_TYPE_ARRAY_STRUCT_1 = 12, 3716 3717 BL_IMPL_TYPE_ARRAY_STRUCT_2 = 13, 3718 3719 BL_IMPL_TYPE_ARRAY_STRUCT_3 = 14, 3720 3721 BL_IMPL_TYPE_ARRAY_STRUCT_4 = 15, 3722 3723 BL_IMPL_TYPE_ARRAY_STRUCT_6 = 16, 3724 3725 BL_IMPL_TYPE_ARRAY_STRUCT_8 = 17, 3726 3727 BL_IMPL_TYPE_ARRAY_STRUCT_10 = 18, 3728 3729 BL_IMPL_TYPE_ARRAY_STRUCT_12 = 19, 3730 3731 BL_IMPL_TYPE_ARRAY_STRUCT_16 = 20, 3732 3733 BL_IMPL_TYPE_ARRAY_STRUCT_20 = 21, 3734 3735 BL_IMPL_TYPE_ARRAY_STRUCT_24 = 22, 3736 3737 BL_IMPL_TYPE_ARRAY_STRUCT_32 = 23, 3738 3739 BL_IMPL_TYPE_BIT_ARRAY = 32, 3740 3741 BL_IMPL_TYPE_BIT_SET = 33, 3742 3743 BL_IMPL_TYPE_STRING = 39, 3744 3745 BL_IMPL_TYPE_PATH = 40, 3746 3747 BL_IMPL_TYPE_REGION = 43, 3748 3749 BL_IMPL_TYPE_IMAGE = 44, 3750 3751 BL_IMPL_TYPE_IMAGE_CODEC = 45, 3752 3753 BL_IMPL_TYPE_IMAGE_DECODER = 46, 3754 3755 BL_IMPL_TYPE_IMAGE_ENCODER = 47, 3756 3757 BL_IMPL_TYPE_GRADIENT = 48, 3758 3759 BL_IMPL_TYPE_PATTERN = 49, 3760 3761 BL_IMPL_TYPE_CONTEXT = 55, 3762 3763 BL_IMPL_TYPE_FONT = 56, 3764 3765 BL_IMPL_TYPE_FONT_FACE = 57, 3766 3767 BL_IMPL_TYPE_FONT_DATA = 58, 3768 3769 BL_IMPL_TYPE_FONT_MANAGER = 59, 3770 3771 BL_IMPL_TYPE_FONT_FEATURE_OPTIONS = 60, 3772 3773 BL_IMPL_TYPE_FONT_VARIATION_OPTIONS = 61, 3774 3775 BL_IMPL_TYPE_COUNT = 64 3776 } 3777 3778 enum BLImplTraits 3779 { 3780 BL_IMPL_TRAIT_MUTABLE = 0x01u, 3781 3782 BL_IMPL_TRAIT_IMMUTABLE = 0x02u, 3783 3784 BL_IMPL_TRAIT_EXTERNAL = 0x04u, 3785 3786 BL_IMPL_TRAIT_FOREIGN = 0x08u, 3787 3788 BL_IMPL_TRAIT_VIRT = 0x10u, 3789 3790 BL_IMPL_TRAIT_NULL = 0x80u 3791 } 3792 3793 struct BLVariantImpl 3794 { 3795 union 3796 { 3797 const(void)* virt; 3798 3799 uintptr_t unknownHeaderData; 3800 } 3801 3802 size_t refCount; 3803 3804 ubyte implType; 3805 3806 ubyte implTraits; 3807 3808 ushort memPoolData; 3809 3810 ubyte[4] reserved; 3811 } 3812 3813 struct BLVariantCore 3814 { 3815 BLVariantImpl* impl; 3816 } 3817 3818 extern __gshared BLVariantCore[BL_IMPL_TYPE_COUNT] blNone;