1/* 2 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26#ifndef GraphicsPrimitiveMgr_h_Included 27#define GraphicsPrimitiveMgr_h_Included 28 29#ifdef __cplusplus 30extern "C" { 31#endif 32 33#include <stddef.h> 34 35#include "java_awt_AlphaComposite.h" 36 37#include "SurfaceData.h" 38#include "SpanIterator.h" 39 40#include "j2d_md.h" 41 42#include "AlphaMath.h" 43#include "GlyphImageRef.h" 44 45/* 46 * This structure contains all of the information about a particular 47 * type of GraphicsPrimitive, such as a FillRect, a MaskFill, or a Blit. 48 * 49 * A global collection of these structures is declared and initialized 50 * to contain the necessary Java (JNI) information so that appropriate 51 * Java GraphicsPrimitive objects can be quickly constructed for a set 52 * of native loops simply by referencing the necessary entry from that 53 * collection for the type of primitive being registered. 54 * 55 * See PrimitiveTypes.{Blit,BlitBg,FillRect,...} below. 56 */ 57typedef struct _PrimitiveType { 58 char *ClassName; 59 jint srcflags; 60 jint dstflags; 61 jclass ClassObject; 62 jmethodID Constructor; 63} PrimitiveType; 64 65/* The integer constants to identify the compositing rule being defined. */ 66#define RULE_Xor (java_awt_AlphaComposite_MIN_RULE - 1) 67#define RULE_Clear java_awt_AlphaComposite_CLEAR 68#define RULE_Src java_awt_AlphaComposite_SRC 69#define RULE_SrcOver java_awt_AlphaComposite_SRC_OVER 70#define RULE_DstOver java_awt_AlphaComposite_DST_OVER 71#define RULE_SrcIn java_awt_AlphaComposite_SRC_IN 72#define RULE_DstIn java_awt_AlphaComposite_DST_IN 73#define RULE_SrcOut java_awt_AlphaComposite_SRC_OUT 74#define RULE_DstOut java_awt_AlphaComposite_DST_OUT 75 76/* 77 * This structure holds the information retrieved from a Java 78 * Composite object for easy transfer to various C functions 79 * that implement the inner loop for a native primitive. 80 * 81 * Currently only AlphaComposite and XORComposite are supported. 82 */ 83typedef struct _CompositeInfo { 84 jint rule; /* See RULE_* constants above */ 85 union { 86 jfloat extraAlpha; /* from AlphaComposite */ 87 jint xorPixel; /* from XORComposite */ 88 } details; 89 juint alphaMask; /* from XORComposite */ 90} CompositeInfo; 91 92/* 93 * This structure is the common header for the two native structures 94 * that hold information about a particular SurfaceType or CompositeType. 95 * 96 * A global collection of these structures is declared and initialized 97 * to contain the necessary Java (JNI) information so that appropriate 98 * Java GraphicsPrimitive objects can be quickly constructed for a set 99 * of native loops simply by referencing the necessary entry from that 100 * collection for the type of composite or surface being implemented. 101 * 102 * See SurfaceTypes.{OpaqueColor,IntArgb,ByteGray,...} below. 103 * See CompositeTypes.{Xor,AnyAlpha,...} below. 104 */ 105typedef struct _SurfCompHdr { 106 char *Name; 107 jobject Object; 108} SurfCompHdr; 109 110/* 111 * The definitions for the SurfaceType structure described above. 112 */ 113 114/* 115 * The signature for a function that returns the specific integer 116 * format pixel for a given ARGB color value for a particular 117 * SurfaceType implementation. 118 * This function is valid only after GetRasInfo call for the 119 * associated surface. 120 */ 121typedef jint (PixelForFunc)(SurfaceDataRasInfo *pRasInfo, jint rgb); 122 123/* 124 * The additional information needed to manipulate a surface: 125 * - The pixelFor function for translating ARGB values. 126 * Valid only after GetRasInfo call for this surface. 127 * - The additional flags needed when reading from this surface. 128 * - The additional flags needed when writing to this surface. 129 */ 130typedef struct _SurfaceType { 131 SurfCompHdr hdr; 132 PixelForFunc *pixelFor; 133 jint readflags; 134 jint writeflags; 135} SurfaceType; 136 137/* 138 * The definitions for the CompositeType structure described above. 139 */ 140 141/* 142 * The signature for a function that fills in a CompositeInfo 143 * structure from the information present in a given Java Composite 144 * object. 145 */ 146typedef void (JNICALL CompInfoFunc)(JNIEnv *env, 147 CompositeInfo *pCompInfo, 148 jobject Composite); 149 150/* 151 * The additional information needed to implement a primitive that 152 * performs a particular composite operation: 153 * - The getCompInfo function for filling in a CompositeInfo structure. 154 * - The additional flags needed for locking the destination surface. 155 */ 156typedef struct _CompositeType { 157 SurfCompHdr hdr; 158 CompInfoFunc *getCompInfo; 159 jint dstflags; 160} CompositeType; 161 162/* 163 * The signature of the native functions that register a set of 164 * related native GraphicsPrimitive functions. 165 */ 166typedef jboolean (RegisterFunc)(JNIEnv *env); 167 168struct _NativePrimitive; /* forward reference for function typedefs */ 169 170/* 171 * This empty function signature represents an "old pre-ANSI style" 172 * function declaration which makes no claims about the argument list 173 * other than that the types of the arguments will undergo argument 174 * promotion in the calling conventions. 175 * (See section A7.3.2 in K&R 2nd edition.) 176 * 177 * When trying to statically initialize the function pointer field of 178 * a NativePrimitive structure, which is a union of all possible 179 * inner loop function signatures, the initializer constant must be 180 * compatible with the first field in the union. This generic function 181 * type allows us to assign any function pointer to that union as long 182 * as it meets the requirements specified above (i.e. all arguments 183 * are compatible with their promoted values according to the old 184 * style argument promotion calling semantics). 185 * 186 * Note: This means that you cannot define an argument to any of 187 * these native functions which is a byte or a short as that value 188 * would not be passed in the same way for an ANSI-style full prototype 189 * calling convention and an old-style argument promotion calling 190 * convention. 191 */ 192typedef void (AnyFunc)(); 193 194/* 195 * The signature of the inner loop function for a "Blit". 196 */ 197typedef void (BlitFunc)(void *pSrc, void *pDst, 198 juint width, juint height, 199 SurfaceDataRasInfo *pSrcInfo, 200 SurfaceDataRasInfo *pDstInfo, 201 struct _NativePrimitive *pPrim, 202 CompositeInfo *pCompInfo); 203 204/* 205 * The signature of the inner loop function for a "BlitBg". 206 */ 207typedef void (BlitBgFunc)(void *pSrc, void *pDst, 208 juint width, juint height, jint bgpixel, 209 SurfaceDataRasInfo *pSrcInfo, 210 SurfaceDataRasInfo *pDstInfo, 211 struct _NativePrimitive *pPrim, 212 CompositeInfo *pCompInfo); 213 214/* 215 * The signature of the inner loop function for a "ScaleBlit". 216 */ 217typedef void (ScaleBlitFunc)(void *pSrc, void *pDst, 218 juint dstwidth, juint dstheight, 219 jint sxloc, jint syloc, 220 jint sxinc, jint syinc, jint scale, 221 SurfaceDataRasInfo *pSrcInfo, 222 SurfaceDataRasInfo *pDstInfo, 223 struct _NativePrimitive *pPrim, 224 CompositeInfo *pCompInfo); 225 226/* 227 * The signature of the inner loop function for a "FillRect". 228 */ 229typedef void (FillRectFunc)(SurfaceDataRasInfo *pRasInfo, 230 jint lox, jint loy, 231 jint hix, jint hiy, 232 jint pixel, struct _NativePrimitive *pPrim, 233 CompositeInfo *pCompInfo); 234 235/* 236 * The signature of the inner loop function for a "FillSpans". 237 */ 238typedef void (FillSpansFunc)(SurfaceDataRasInfo *pRasInfo, 239 SpanIteratorFuncs *pSpanFuncs, void *siData, 240 jint pixel, struct _NativePrimitive *pPrim, 241 CompositeInfo *pCompInfo); 242 243/* 244 * The signature of the inner loop function for a "DrawLine". 245 * Note that this same inner loop is used for native DrawRect 246 * and DrawPolygons primitives. 247 */ 248typedef void (DrawLineFunc)(SurfaceDataRasInfo *pRasInfo, 249 jint x1, jint y1, jint pixel, 250 jint steps, jint error, 251 jint bumpmajormask, jint errmajor, 252 jint bumpminormask, jint errminor, 253 struct _NativePrimitive *pPrim, 254 CompositeInfo *pCompInfo); 255 256/* 257 * The signature of the inner loop function for a "MaskFill". 258 */ 259typedef void (MaskFillFunc)(void *pRas, 260 unsigned char *pMask, jint maskOff, jint maskScan, 261 jint width, jint height, 262 jint fgColor, 263 SurfaceDataRasInfo *pRasInfo, 264 struct _NativePrimitive *pPrim, 265 CompositeInfo *pCompInfo); 266 267/* 268 * The signature of the inner loop function for a "MaskBlit". 269 */ 270typedef void (MaskBlitFunc)(void *pDst, void *pSrc, 271 unsigned char *pMask, jint maskOff, jint maskScan, 272 jint width, jint height, 273 SurfaceDataRasInfo *pDstInfo, 274 SurfaceDataRasInfo *pSrcInfo, 275 struct _NativePrimitive *pPrim, 276 CompositeInfo *pCompInfo); 277/* 278 * The signature of the inner loop function for a "DrawGlyphList". 279 */ 280typedef void (DrawGlyphListFunc)(SurfaceDataRasInfo *pRasInfo, 281 ImageRef *glyphs, 282 jint totalGlyphs, 283 jint fgpixel, jint fgcolor, 284 jint cx1, jint cy1, 285 jint cx2, jint cy2, 286 struct _NativePrimitive *pPrim, 287 CompositeInfo *pCompInfo); 288 289/* 290 * The signature of the inner loop function for a "DrawGlyphListAA". 291 */ 292typedef void (DrawGlyphListAAFunc)(SurfaceDataRasInfo *pRasInfo, 293 ImageRef *glyphs, 294 jint totalGlyphs, 295 jint fgpixel, jint fgcolor, 296 jint cx1, jint cy1, 297 jint cx2, jint cy2, 298 struct _NativePrimitive *pPrim, 299 CompositeInfo *pCompInfo); 300 301/* 302 * The signature of the inner loop function for a "DrawGlyphListLCD". 303 * rgbOrder is a jint rather than a jboolean so that this typedef matches 304 * AnyFunc which is the first element in a union in NativePrimitive's 305 * initialiser. See the comments alongside declaration of the AnyFunc type for 306 * a full explanation. 307 */ 308typedef void (DrawGlyphListLCDFunc)(SurfaceDataRasInfo *pRasInfo, 309 ImageRef *glyphs, 310 jint totalGlyphs, 311 jint fgpixel, jint fgcolor, 312 jint cx1, jint cy1, 313 jint cx2, jint cy2, 314 jint rgbOrder, 315 unsigned char *gammaLut, 316 unsigned char *invGammaLut, 317 struct _NativePrimitive *pPrim, 318 CompositeInfo *pCompInfo); 319 320/* 321 * The signature of the inner loop functions for a "TransformHelper". 322 */ 323typedef void (TransformHelperFunc)(SurfaceDataRasInfo *pSrcInfo, 324 jint *pRGB, jint numpix, 325 jlong xlong, jlong dxlong, 326 jlong ylong, jlong dylong); 327 328typedef struct { 329 TransformHelperFunc *nnHelper; 330 TransformHelperFunc *blHelper; 331 TransformHelperFunc *bcHelper; 332} TransformHelperFuncs; 333 334typedef void (TransformInterpFunc)(jint *pRGBbase, jint numpix, 335 jint xfract, jint dxfract, 336 jint yfract, jint dyfract); 337 338/* 339 * The signature of the inner loop function for a "FillParallelogram" 340 * Note that this same inner loop is used for native DrawParallelogram 341 * primitives. 342 * Note that these functions are paired with equivalent DrawLine 343 * inner loop functions to facilitate nicer looking and faster thin 344 * transformed drawrect calls. 345 */ 346typedef void (FillParallelogramFunc)(SurfaceDataRasInfo *pRasInfo, 347 jint lox, jint loy, jint hix, jint hiy, 348 jlong leftx, jlong dleftx, 349 jlong rightx, jlong drightx, 350 jint pixel, struct _NativePrimitive *pPrim, 351 CompositeInfo *pCompInfo); 352 353typedef struct { 354 FillParallelogramFunc *fillpgram; 355 DrawLineFunc *drawline; 356} DrawParallelogramFuncs; 357 358/* 359 * This structure contains all information for defining a single 360 * native GraphicsPrimitive, including: 361 * - The information about the type of the GraphicsPrimitive subclass. 362 * - The information about the type of the source surface. 363 * - The information about the type of the compositing operation. 364 * - The information about the type of the destination surface. 365 * - A pointer to the function that performs the actual inner loop work. 366 * - Extra flags needed for locking the source and destination surfaces 367 * above and beyond the flags specified in the Primitive, Composite 368 * and SurfaceType structures. (For most native primitives these 369 * flags can be calculated automatically from information stored in 370 * the PrimitiveType, SurfaceType, and CompositeType structures.) 371 */ 372typedef struct _NativePrimitive { 373 PrimitiveType *pPrimType; 374 SurfaceType *pSrcType; 375 CompositeType *pCompType; 376 SurfaceType *pDstType; 377 /* See declaration of AnyFunc type above for comments explaining why 378 * only AnyFunc is used by the initializers for these union fields 379 * and consequent type restrictions. 380 */ 381 union { 382 AnyFunc *initializer; 383 BlitFunc *blit; 384 BlitBgFunc *blitbg; 385 ScaleBlitFunc *scaledblit; 386 FillRectFunc *fillrect; 387 FillSpansFunc *fillspans; 388 FillParallelogramFunc *fillparallelogram; 389 DrawParallelogramFuncs *drawparallelogram; 390 DrawLineFunc *drawline; 391 MaskFillFunc *maskfill; 392 MaskBlitFunc *maskblit; 393 DrawGlyphListFunc *drawglyphlist; 394 DrawGlyphListFunc *drawglyphlistaa; 395 DrawGlyphListLCDFunc *drawglyphlistlcd; 396 TransformHelperFuncs *transformhelpers; 397 } funcs, funcs_c; 398 jint srcflags; 399 jint dstflags; 400} NativePrimitive; 401 402/* 403 * This function should be defined to return a pointer to 404 * an accelerated version of a primitive function 'func_c' 405 * if it exists and to return a copy of the input parameter 406 * otherwise. 407 */ 408extern AnyFunc* MapAccelFunction(AnyFunc *func_c); 409 410/* 411 * The global collection of all primitive types. Specific NativePrimitive 412 * structures can be statically initialized by pointing to these structures. 413 */ 414extern struct _PrimitiveTypes { 415 PrimitiveType Blit; 416 PrimitiveType BlitBg; 417 PrimitiveType ScaledBlit; 418 PrimitiveType FillRect; 419 PrimitiveType FillSpans; 420 PrimitiveType FillParallelogram; 421 PrimitiveType DrawParallelogram; 422 PrimitiveType DrawLine; 423 PrimitiveType DrawRect; 424 PrimitiveType DrawPolygons; 425 PrimitiveType DrawPath; 426 PrimitiveType FillPath; 427 PrimitiveType MaskBlit; 428 PrimitiveType MaskFill; 429 PrimitiveType DrawGlyphList; 430 PrimitiveType DrawGlyphListAA; 431 PrimitiveType DrawGlyphListLCD; 432 PrimitiveType TransformHelper; 433} PrimitiveTypes; 434 435/* 436 * The global collection of all surface types. Specific NativePrimitive 437 * structures can be statically initialized by pointing to these structures. 438 */ 439extern struct _SurfaceTypes { 440 SurfaceType OpaqueColor; 441 SurfaceType AnyColor; 442 SurfaceType AnyByte; 443 SurfaceType ByteBinary1Bit; 444 SurfaceType ByteBinary2Bit; 445 SurfaceType ByteBinary4Bit; 446 SurfaceType ByteIndexed; 447 SurfaceType ByteIndexedBm; 448 SurfaceType ByteGray; 449 SurfaceType Index8Gray; 450 SurfaceType Index12Gray; 451 SurfaceType AnyShort; 452 SurfaceType Ushort555Rgb; 453 SurfaceType Ushort555Rgbx; 454 SurfaceType Ushort565Rgb; 455 SurfaceType Ushort4444Argb; 456 SurfaceType UshortGray; 457 SurfaceType UshortIndexed; 458 SurfaceType Any3Byte; 459 SurfaceType ThreeByteBgr; 460 SurfaceType AnyInt; 461 SurfaceType IntArgb; 462 SurfaceType IntArgbPre; 463 SurfaceType IntArgbBm; 464 SurfaceType IntRgb; 465 SurfaceType IntBgr; 466 SurfaceType IntRgbx; 467 SurfaceType Any4Byte; 468 SurfaceType FourByteAbgr; 469 SurfaceType FourByteAbgrPre; 470} SurfaceTypes; 471 472/* 473 * The global collection of all composite types. Specific NativePrimitive 474 * structures can be statically initialized by pointing to these structures. 475 */ 476extern struct _CompositeTypes { 477 CompositeType SrcNoEa; 478 CompositeType SrcOverNoEa; 479 CompositeType SrcOverBmNoEa; 480 CompositeType Src; 481 CompositeType SrcOver; 482 CompositeType Xor; 483 CompositeType AnyAlpha; 484} CompositeTypes; 485 486#define ArraySize(A) (sizeof(A) / sizeof(A[0])) 487 488#define PtrAddBytes(p, b) ((void *) (((intptr_t) (p)) + (b))) 489#define PtrCoord(p, x, xinc, y, yinc) PtrAddBytes(p, \ 490 ((ptrdiff_t)(y))*(yinc) + \ 491 ((ptrdiff_t)(x))*(xinc)) 492 493/* 494 * The function to call with an array of NativePrimitive structures 495 * to register them with the Java GraphicsPrimitiveMgr. 496 */ 497extern jboolean RegisterPrimitives(JNIEnv *env, 498 NativePrimitive *pPrim, 499 jint NumPrimitives); 500 501/* 502 * The utility function to retrieve the NativePrimitive structure 503 * from a given Java GraphicsPrimitive object. 504 */ 505extern JNIEXPORT NativePrimitive * JNICALL 506GetNativePrim(JNIEnv *env, jobject gp); 507 508/* 509 * Utility functions to get values from a Java SunGraphics2D or Color object. 510 */ 511extern JNIEXPORT void JNICALL 512GrPrim_Sg2dGetCompInfo(JNIEnv *env, jobject sg2d, 513 NativePrimitive *pPrim, 514 CompositeInfo *pCompInfo); 515extern JNIEXPORT jint JNICALL 516GrPrim_CompGetXorColor(JNIEnv *env, jobject comp); 517extern JNIEXPORT void JNICALL 518GrPrim_CompGetXorInfo(JNIEnv *env, CompositeInfo *pCompInfo, jobject comp); 519extern JNIEXPORT void JNICALL 520GrPrim_CompGetAlphaInfo(JNIEnv *env, CompositeInfo *pCompInfo, jobject comp); 521 522extern JNIEXPORT void JNICALL 523GrPrim_Sg2dGetClip(JNIEnv *env, jobject sg2d, 524 SurfaceDataBounds *bounds); 525 526extern JNIEXPORT jint JNICALL 527GrPrim_Sg2dGetPixel(JNIEnv *env, jobject sg2d); 528extern JNIEXPORT jint JNICALL 529GrPrim_Sg2dGetEaRGB(JNIEnv *env, jobject sg2d); 530extern JNIEXPORT jint JNICALL 531GrPrim_Sg2dGetLCDTextContrast(JNIEnv *env, jobject sg2d); 532 533/* 534 * Data structure and functions to retrieve and use 535 * AffineTransform objects from the native level. 536 */ 537typedef struct { 538 jdouble dxdx; /* dx in dest space for each dx in src space */ 539 jdouble dxdy; /* dx in dest space for each dy in src space */ 540 jdouble tx; 541 jdouble dydx; /* dy in dest space for each dx in src space */ 542 jdouble dydy; /* dy in dest space for each dy in src space */ 543 jdouble ty; 544} TransformInfo; 545 546extern JNIEXPORT void JNICALL 547Transform_GetInfo(JNIEnv *env, jobject txform, TransformInfo *pTxInfo); 548extern JNIEXPORT void JNICALL 549Transform_transform(TransformInfo *pTxInfo, jdouble *pX, jdouble *pY); 550 551void GrPrim_RefineBounds(SurfaceDataBounds *bounds, jint transX, jint transY, 552 jfloat *coords, jint maxCoords); 553 554extern jfieldID path2DTypesID; 555extern jfieldID path2DNumTypesID; 556extern jfieldID path2DWindingRuleID; 557extern jfieldID path2DFloatCoordsID; 558extern jfieldID sg2dStrokeHintID; 559extern jint sunHints_INTVAL_STROKE_PURE; 560 561/* 562 * Macros for using jlong variables as 32bits.32bits fractional values 563 */ 564#define LongOneHalf (((jlong) 1) << 31) 565#define IntToLong(i) (((jlong) (i)) << 32) 566#define DblToLong(d) ((jlong) ((d) * IntToLong(1))) 567#define LongToDbl(l) (((jdouble) l) / IntToLong(1)) 568#define WholeOfLong(l) ((jint) ((l) >> 32)) 569#define FractOfLong(l) ((jint) (l)) 570#define URShift(i, n) (((juint) (i)) >> (n)) 571 572/* 573 * Macros to help in defining arrays of NativePrimitive structures. 574 * 575 * These macros are the very base macros. More specific macros are 576 * defined in LoopMacros.h. 577 * 578 * Note that the DrawLine, DrawRect, and DrawPolygons primitives are 579 * all registered together from a single shared native function pointer. 580 */ 581 582#define REGISTER_PRIMITIVE(TYPE, SRC, COMP, DST, FUNC) \ 583 { \ 584 & PrimitiveTypes.TYPE, \ 585 & SurfaceTypes.SRC, \ 586 & CompositeTypes.COMP, \ 587 & SurfaceTypes.DST, \ 588 {FUNC}, \ 589 {FUNC}, \ 590 0, \ 591 0 \ 592 } 593 594#define REGISTER_PRIMITIVE_FLAGS(TYPE, SRC, COMP, DST, FUNC, SFLAGS, DFLAGS) \ 595 { \ 596 & PrimitiveTypes.TYPE, \ 597 & SurfaceTypes.SRC, \ 598 & CompositeTypes.COMP, \ 599 & SurfaceTypes.DST, \ 600 {FUNC}, \ 601 {FUNC}, \ 602 SFLAGS, \ 603 DFLAGS, \ 604 } 605 606#define REGISTER_BLIT(SRC, COMP, DST, FUNC) \ 607 REGISTER_PRIMITIVE(Blit, SRC, COMP, DST, FUNC) 608 609#define REGISTER_BLIT_FLAGS(SRC, COMP, DST, FUNC, SFLAGS, DFLAGS) \ 610 REGISTER_PRIMITIVE_FLAGS(Blit, SRC, COMP, DST, FUNC, SFLAGS, DFLAGS) 611 612#define REGISTER_SCALEBLIT(SRC, COMP, DST, FUNC) \ 613 REGISTER_PRIMITIVE(ScaledBlit, SRC, COMP, DST, FUNC) 614 615#define REGISTER_SCALEBLIT_FLAGS(SRC, COMP, DST, FUNC, SFLAGS, DFLAGS) \ 616 REGISTER_PRIMITIVE_FLAGS(ScaledBlit, SRC, COMP, DST, FUNC, SFLAGS, DFLAGS) 617 618#define REGISTER_BLITBG(SRC, COMP, DST, FUNC) \ 619 REGISTER_PRIMITIVE(BlitBg, SRC, COMP, DST, FUNC) 620 621#define REGISTER_FILLRECT(SRC, COMP, DST, FUNC) \ 622 REGISTER_PRIMITIVE(FillRect, SRC, COMP, DST, FUNC) 623 624#define REGISTER_FILLSPANS(SRC, COMP, DST, FUNC) \ 625 REGISTER_PRIMITIVE(FillSpans, SRC, COMP, DST, FUNC) 626 627#define REGISTER_FILLPGRAM(SRC, COMP, DST, FUNC) \ 628 REGISTER_PRIMITIVE(FillParallelogram, SRC, COMP, DST, FUNC), \ 629 REGISTER_PRIMITIVE(DrawParallelogram, SRC, COMP, DST, FUNC) 630 631#define REGISTER_LINE_PRIMITIVES(SRC, COMP, DST, FUNC) \ 632 REGISTER_PRIMITIVE(DrawLine, SRC, COMP, DST, FUNC), \ 633 REGISTER_PRIMITIVE(DrawRect, SRC, COMP, DST, FUNC), \ 634 REGISTER_PRIMITIVE(DrawPolygons, SRC, COMP, DST, FUNC), \ 635 REGISTER_PRIMITIVE(DrawPath, SRC, COMP, DST, FUNC), \ 636 REGISTER_PRIMITIVE(FillPath, SRC, COMP, DST, FUNC) 637 638#define REGISTER_MASKBLIT(SRC, COMP, DST, FUNC) \ 639 REGISTER_PRIMITIVE(MaskBlit, SRC, COMP, DST, FUNC) 640 641#define REGISTER_MASKFILL(SRC, COMP, DST, FUNC) \ 642 REGISTER_PRIMITIVE(MaskFill, SRC, COMP, DST, FUNC) 643 644#define REGISTER_DRAWGLYPHLIST(SRC, COMP, DST, FUNC) \ 645 REGISTER_PRIMITIVE(DrawGlyphList, SRC, COMP, DST, FUNC) 646 647#define REGISTER_DRAWGLYPHLISTAA(SRC, COMP, DST, FUNC) \ 648 REGISTER_PRIMITIVE(DrawGlyphListAA, SRC, COMP, DST, FUNC) 649 650#define REGISTER_DRAWGLYPHLISTLCD(SRC, COMP, DST, FUNC) \ 651 REGISTER_PRIMITIVE(DrawGlyphListLCD, SRC, COMP, DST, FUNC) 652 653#ifdef __cplusplus 654}; 655#endif 656 657#endif /* GraphicsPrimitiveMgr_h_Included */ 658