1 /*
2 Copyright 2010 Google Inc.
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17
18 #ifndef GrTypes_DEFINED
19 #define GrTypes_DEFINED
20
21 #include "SkTypes.h"
22 #include "GrConfig.h"
23
24 ////////////////////////////////////////////////////////////////////////////////
25
26 /**
27 * Defines overloaded bitwise operators to make it easier to use an enum as a
28 * bitfield.
29 */
30 #define GR_MAKE_BITFIELD_OPS(X) \
31 static inline X operator | (X a, X b) { \
32 return (X) (+a | +b); \
33 } \
34 \
35 static inline X operator & (X a, X b) { \
36 return (X) (+a & +b); \
37 } \
38 template <typename T> \
39 static inline X operator & (T a, X b) { \
40 return (X) (+a & +b); \
41 } \
42 template <typename T> \
43 static inline X operator & (X a, T b) { \
44 return (X) (+a & +b); \
45 } \
46
47 ////////////////////////////////////////////////////////////////////////////////
48
49
50 /**
51 * Macro to round n up to the next multiple of 4, or return it unchanged if
52 * n is already a multiple of 4
53 */
54 #define GrALIGN4(n) SkAlign4(n)
55 #define GrIsALIGN4(n) (((n) & 3) == 0)
56
GrMin(const T & a,const T & b)57 template <typename T> const T& GrMin(const T& a, const T& b) {
58 return (a < b) ? a : b;
59 }
60
GrMax(const T & a,const T & b)61 template <typename T> const T& GrMax(const T& a, const T& b) {
62 return (b < a) ? a : b;
63 }
64
65 // compile time versions of min/max
66 #define GR_CT_MAX(a, b) (((b) < (a)) ? (a) : (b))
67 #define GR_CT_MIN(a, b) (((b) < (a)) ? (b) : (a))
68
69 /**
70 * divide, rounding up
71 */
GrUIDivRoundUp(uint32_t x,uint32_t y)72 static inline uint32_t GrUIDivRoundUp(uint32_t x, uint32_t y) {
73 return (x + (y-1)) / y;
74 }
GrSizeDivRoundUp(size_t x,uint32_t y)75 static inline size_t GrSizeDivRoundUp(size_t x, uint32_t y) {
76 return (x + (y-1)) / y;
77 }
78
79 /**
80 * align up
81 */
GrUIAlignUp(uint32_t x,uint32_t alignment)82 static inline uint32_t GrUIAlignUp(uint32_t x, uint32_t alignment) {
83 return GrUIDivRoundUp(x, alignment) * alignment;
84 }
GrSizeAlignUp(size_t x,uint32_t alignment)85 static inline uint32_t GrSizeAlignUp(size_t x, uint32_t alignment) {
86 return GrSizeDivRoundUp(x, alignment) * alignment;
87 }
88
89 /**
90 * amount of pad needed to align up
91 */
GrUIAlignUpPad(uint32_t x,uint32_t alignment)92 static inline uint32_t GrUIAlignUpPad(uint32_t x, uint32_t alignment) {
93 return (alignment - x % alignment) % alignment;
94 }
GrSizeAlignUpPad(size_t x,uint32_t alignment)95 static inline size_t GrSizeAlignUpPad(size_t x, uint32_t alignment) {
96 return (alignment - x % alignment) % alignment;
97 }
98
99 /**
100 * align down
101 */
GrUIAlignDown(uint32_t x,uint32_t alignment)102 static inline uint32_t GrUIAlignDown(uint32_t x, uint32_t alignment) {
103 return (x / alignment) * alignment;
104 }
GrSizeAlignDown(size_t x,uint32_t alignment)105 static inline uint32_t GrSizeAlignDown(size_t x, uint32_t alignment) {
106 return (x / alignment) * alignment;
107 }
108
109 /**
110 * Count elements in an array
111 */
112 #define GR_ARRAY_COUNT(array) SK_ARRAY_COUNT(array)
113
114 //!< allocate a block of memory, will never return NULL
115 extern void* GrMalloc(size_t bytes);
116
117 //!< free block allocated by GrMalloc. ptr may be NULL
118 extern void GrFree(void* ptr);
119
Gr_bzero(void * dst,size_t size)120 static inline void Gr_bzero(void* dst, size_t size) {
121 memset(dst, 0, size);
122 }
123
124 ///////////////////////////////////////////////////////////////////////////////
125
126 /**
127 * Return the number of leading zeros in n
128 */
129 extern int Gr_clz(uint32_t n);
130
131 /**
132 * Return true if n is a power of 2
133 */
GrIsPow2(unsigned n)134 static inline bool GrIsPow2(unsigned n) {
135 return n && 0 == (n & (n - 1));
136 }
137
138 /**
139 * Return the next power of 2 >= n.
140 */
GrNextPow2(uint32_t n)141 static inline uint32_t GrNextPow2(uint32_t n) {
142 return n ? (1 << (32 - Gr_clz(n - 1))) : 1;
143 }
144
145 ///////////////////////////////////////////////////////////////////////////////
146
147 /**
148 * 16.16 fixed point type
149 */
150 typedef int32_t GrFixed;
151
152 #if GR_DEBUG
153
GrToS16(intptr_t x)154 static inline int16_t GrToS16(intptr_t x) {
155 GrAssert((int16_t)x == x);
156 return (int16_t)x;
157 }
158
159 #else
160
161 #define GrToS16(x) x
162
163 #endif
164
165
166 ///////////////////////////////////////////////////////////////////////////////
167
168 /**
169 * Possible 3D APIs that may be used by Ganesh.
170 */
171 enum GrEngine {
172 kOpenGL_Shaders_GrEngine,
173 kOpenGL_Fixed_GrEngine,
174 kDirect3D9_GrEngine
175 };
176
177 /**
178 * Engine-specific 3D context handle
179 * Unused for GL.
180 * IDirect3DDevice9* for D3D9
181 */
182 typedef intptr_t GrPlatform3DContext;
183
184 ///////////////////////////////////////////////////////////////////////////////
185
186 /**
187 * Type used to describe format of vertices in arrays
188 * Values are defined in GrDrawTarget
189 */
190 typedef int GrVertexLayout;
191
192 /**
193 * Geometric primitives used for drawing.
194 */
195 enum GrPrimitiveType {
196 kTriangles_PrimitiveType,
197 kTriangleStrip_PrimitiveType,
198 kTriangleFan_PrimitiveType,
199 kPoints_PrimitiveType,
200 kLines_PrimitiveType,
201 kLineStrip_PrimitiveType
202 };
203
GrIsPrimTypeLines(GrPrimitiveType type)204 static inline bool GrIsPrimTypeLines(GrPrimitiveType type) {
205 return kLines_PrimitiveType == type || kLineStrip_PrimitiveType == type;
206 }
207
GrIsPrimTypeTris(GrPrimitiveType type)208 static inline bool GrIsPrimTypeTris(GrPrimitiveType type) {
209 return kTriangles_PrimitiveType == type ||
210 kTriangleStrip_PrimitiveType == type ||
211 kTriangleFan_PrimitiveType == type;
212 }
213
214 /**
215 * Coeffecients for alpha-blending.
216 */
217 enum GrBlendCoeff {
218 kZero_BlendCoeff, //<! 0
219 kOne_BlendCoeff, //<! 1
220 kSC_BlendCoeff, //<! src color
221 kISC_BlendCoeff, //<! one minus src color
222 kDC_BlendCoeff, //<! dst color
223 kIDC_BlendCoeff, //<! one minus dst color
224 kSA_BlendCoeff, //<! src alpha
225 kISA_BlendCoeff, //<! one minus src alpha
226 kDA_BlendCoeff, //<! dst alpha
227 kIDA_BlendCoeff, //<! one minus dst alpha
228 kConstC_BlendCoeff, //<! constant color
229 kIConstC_BlendCoeff, //<! one minus constant color
230 kConstA_BlendCoeff, //<! constant color alpha
231 kIConstA_BlendCoeff, //<! one minus constant color alpha
232
233 kPublicBlendCoeffCount
234 };
235
236 /**
237 * Formats for masks, used by the font cache.
238 * Important that these are 0-based.
239 */
240 enum GrMaskFormat {
241 kA8_GrMaskFormat, //!< 1-byte per pixel
242 kA565_GrMaskFormat //!< 2-bytes per pixel
243 };
244 #define kCount_GrMaskFormats 2
245
246 /**
247 * Return the number of bytes-per-pixel for the specified mask format.
248 */
GrMaskFormatBytesPerPixel(GrMaskFormat format)249 static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) {
250 GrAssert((unsigned)format <= 1);
251 return (int)format + 1;
252 }
253
254 /**
255 * Pixel configurations.
256 */
257 enum GrPixelConfig {
258 kUnknown_GrPixelConfig,
259 kAlpha_8_GrPixelConfig,
260 kIndex_8_GrPixelConfig,
261 kRGB_565_GrPixelConfig,
262 kRGBA_4444_GrPixelConfig, //!< premultiplied
263 kRGBA_8888_GrPixelConfig, //!< premultiplied
264 kRGBX_8888_GrPixelConfig, //!< treat the alpha channel as opaque
265 };
266
GrBytesPerPixel(GrPixelConfig config)267 static inline size_t GrBytesPerPixel(GrPixelConfig config) {
268 switch (config) {
269 case kAlpha_8_GrPixelConfig:
270 case kIndex_8_GrPixelConfig:
271 return 1;
272 case kRGB_565_GrPixelConfig:
273 case kRGBA_4444_GrPixelConfig:
274 return 2;
275 case kRGBA_8888_GrPixelConfig:
276 case kRGBX_8888_GrPixelConfig:
277 return 4;
278 default:
279 return 0;
280 }
281 }
282
GrPixelConfigIsOpaque(GrPixelConfig config)283 static inline bool GrPixelConfigIsOpaque(GrPixelConfig config) {
284 switch (config) {
285 case kRGB_565_GrPixelConfig:
286 case kRGBX_8888_GrPixelConfig:
287 return true;
288 default:
289 return false;
290 }
291 }
292
GrPixelConfigIsAlphaOnly(GrPixelConfig config)293 static inline bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) {
294 switch (config) {
295 case kAlpha_8_GrPixelConfig:
296 return true;
297 default:
298 return false;
299 }
300 }
301
302 /**
303 * Used to control the level of antialiasing available for a rendertarget.
304 * Anti-alias quality levels depend on the underlying API/GPU capabilities.
305 */
306 enum GrAALevels {
307 kNone_GrAALevel, //<! No antialiasing available.
308 kLow_GrAALevel, //<! Low quality antialiased rendering. Actual
309 // interpretation is platform-dependent.
310 kMed_GrAALevel, //<! Medium quality antialiased rendering. Actual
311 // interpretation is platform-dependent.
312 kHigh_GrAALevel, //<! High quality antialiased rendering. Actual
313 // interpretation is platform-dependent.
314 };
315
316 /**
317 * Optional bitfield flags that can be passed to createTexture.
318 */
319 enum GrTextureFlags {
320 kNone_GrTextureFlags = 0x0,
321 /**
322 * Creates a texture that can be rendered to as a GrRenderTarget. Use
323 * GrTexture::asRenderTarget() to access.
324 */
325 kRenderTarget_GrTextureFlagBit = 0x1,
326 /**
327 * By default all render targets have an associated stencil buffer that
328 * may be required for path filling. This flag overrides stencil buffer
329 * creation.
330 * MAKE THIS PRIVATE?
331 */
332 kNoStencil_GrTextureFlagBit = 0x2,
333 /**
334 * Hint that the CPU may modify this texture after creation.
335 */
336 kDynamicUpdate_GrTextureFlagBit = 0x4,
337 };
338
339 GR_MAKE_BITFIELD_OPS(GrTextureFlags)
340
341 enum {
342 /**
343 * For Index8 pixel config, the colortable must be 256 entries
344 */
345 kGrColorTableSize = 256 * 4 //sizeof(GrColor)
346 };
347
348 /**
349 * Describes a texture to be created.
350 */
351 struct GrTextureDesc {
352 GrTextureFlags fFlags; //!< bitfield of TextureFlags
353 /**
354 * The level of antialiasing available for a rendertarget texture. Only used
355 * fFlags contains kRenderTarget_GrTextureFlag.
356 */
357 GrAALevels fAALevel;
358 uint32_t fWidth; //!< Width of the texture
359 uint32_t fHeight; //!< Height of the texture
360 /**
361 * Format of source data of the texture. Not guaraunteed to be the same as
362 * internal format used by 3D API.
363 */
364 GrPixelConfig fFormat;
365 };
366
367 /**
368 * Set Operations used to construct clips.
369 */
370 enum GrSetOp {
371 kReplace_SetOp,
372 kIntersect_SetOp,
373 kUnion_SetOp,
374 kXor_SetOp,
375 kDifference_SetOp,
376 kReverseDifference_SetOp,
377 };
378
379 /**
380 * Clips are composed from these objects.
381 */
382 enum GrClipType {
383 kRect_ClipType,
384 kPath_ClipType
385 };
386
387 /**
388 * Commands used to describe a path. Each command
389 * is accompanied by some number of points.
390 */
391 enum GrPathCmd {
392 kMove_PathCmd, //!< Starts a new subpath at
393 // at the returned point
394 // 1 point
395 kLine_PathCmd, //!< Adds a line segment
396 // 2 points
397 kQuadratic_PathCmd, //!< Adds a quadratic segment
398 // 3 points
399 kCubic_PathCmd, //!< Adds a cubic segment
400 // 4 points
401 kClose_PathCmd, //!< Closes the current subpath
402 // by connecting a line to the
403 // starting point.
404 // 0 points
405 kEnd_PathCmd //!< Indicates the end of the last subpath
406 // when iterating
407 // 0 points.
408 };
409
410 /**
411 * Gets the number of points associated with a path command.
412 */
NumPathCmdPoints(GrPathCmd cmd)413 static int inline NumPathCmdPoints(GrPathCmd cmd) {
414 static const int gNumPoints[] = {
415 1, 2, 3, 4, 0, 0
416 };
417 return gNumPoints[cmd];
418 }
419
420 /**
421 * Path filling rules
422 */
423 enum GrPathFill {
424 kWinding_PathFill,
425 kEvenOdd_PathFill,
426 kInverseWinding_PathFill,
427 kInverseEvenOdd_PathFill,
428 kHairLine_PathFill,
429
430 kPathFillCount
431 };
432
NonInvertedFill(GrPathFill fill)433 static inline GrPathFill NonInvertedFill(GrPathFill fill) {
434 static const GrPathFill gNonInvertedFills[] = {
435 kWinding_PathFill, // kWinding_PathFill
436 kEvenOdd_PathFill, // kEvenOdd_PathFill
437 kWinding_PathFill, // kInverseWinding_PathFill
438 kEvenOdd_PathFill, // kInverseEvenOdd_PathFill
439 kHairLine_PathFill,// kHairLine_PathFill
440 };
441 GR_STATIC_ASSERT(0 == kWinding_PathFill);
442 GR_STATIC_ASSERT(1 == kEvenOdd_PathFill);
443 GR_STATIC_ASSERT(2 == kInverseWinding_PathFill);
444 GR_STATIC_ASSERT(3 == kInverseEvenOdd_PathFill);
445 GR_STATIC_ASSERT(4 == kHairLine_PathFill);
446 GR_STATIC_ASSERT(5 == kPathFillCount);
447 return gNonInvertedFills[fill];
448 }
449
IsFillInverted(GrPathFill fill)450 static inline bool IsFillInverted(GrPathFill fill) {
451 static const bool gIsFillInverted[] = {
452 false, // kWinding_PathFill
453 false, // kEvenOdd_PathFill
454 true, // kInverseWinding_PathFill
455 true, // kInverseEvenOdd_PathFill
456 false, // kHairLine_PathFill
457 };
458 GR_STATIC_ASSERT(0 == kWinding_PathFill);
459 GR_STATIC_ASSERT(1 == kEvenOdd_PathFill);
460 GR_STATIC_ASSERT(2 == kInverseWinding_PathFill);
461 GR_STATIC_ASSERT(3 == kInverseEvenOdd_PathFill);
462 GR_STATIC_ASSERT(4 == kHairLine_PathFill);
463 GR_STATIC_ASSERT(5 == kPathFillCount);
464 return gIsFillInverted[fill];
465 }
466
467 /**
468 * Hints provided about a path's convexity (or lack thereof).
469 */
470 enum GrConvexHint {
471 kNone_ConvexHint, //<! No hint about convexity
472 // of the path
473 kConvex_ConvexHint, //<! Path is one convex piece
474 kNonOverlappingConvexPieces_ConvexHint, //<! Multiple convex pieces,
475 // pieces are known to be
476 // disjoint
477 kSameWindingConvexPieces_ConvexHint, //<! Multiple convex pieces,
478 // may or may not intersect,
479 // either all wind cw or all
480 // wind ccw.
481 kConcave_ConvexHint //<! Path is known to be
482 // concave
483 };
484
485 ///////////////////////////////////////////////////////////////////////////////
486
487 enum GrPlatformSurfaceType {
488 /**
489 * Specifies that the object being created is a render target.
490 */
491 kRenderTarget_GrPlatformSurfaceType,
492 /**
493 * Specifies that the object being created is a texture.
494 */
495 kTexture_GrPlatformSurfaceType,
496 /**
497 * Specifies that the object being created is a texture and a render
498 * target.
499 */
500 kTextureRenderTarget_GrPlatformSurfaceType,
501 };
502
503 enum GrPlatformRenderTargetFlags {
504 kNone_GrPlatformRenderTargetFlagBit = 0x0,
505 /**
506 * Specifies that the object being created is multisampled.
507 */
508 kIsMultisampled_GrPlatformRenderTargetFlagBit = 0x1,
509 /**
510 * Gives permission to Gr to perform the downsample-resolve of a
511 * multisampled render target. If this is not set then read pixel
512 * operations may fail. If the object is both a texture and render target
513 * then this *must* be set. Otherwise, if the client wants do its own
514 * resolves it must create separate GrRenderTarget and GrTexture objects
515 * and insert appropriate flushes and resolves betweeen data hazards.
516 * GrRenderTarget has a flagForResolve()
517 */
518 kGrCanResolve_GrPlatformRenderTargetFlagBit = 0x2,
519 };
520
521 GR_MAKE_BITFIELD_OPS(GrPlatformRenderTargetFlags)
522
523 // opaque type for 3D API object handles
524 typedef intptr_t GrPlatform3DObject;
525
526 /**
527 * Description of platform surface to create. See below for GL example.
528 */
529 struct GrPlatformSurfaceDesc {
530 GrPlatformSurfaceType fSurfaceType; // type of surface to create
531 /**
532 * Flags for kRenderTarget and kTextureRenderTarget surface types
533 */
534 GrPlatformRenderTargetFlags fRenderTargetFlags;
535
536 int fWidth; // width in pixels
537 int fHeight; // height in pixels
538 GrPixelConfig fConfig; // color format
539 /**
540 * Number of per sample stencil buffer. Only relevant if kIsRenderTarget is
541 * set in fFlags.
542 */
543 int fStencilBits;
544 /**
545 * Texture object in 3D API. Only relevant if fSurfaceType is kTexture or
546 * kTextureRenderTarget.
547 * GL: this is a texture object (glGenTextures)
548 */
549 GrPlatform3DObject fPlatformTexture;
550 /**
551 * Render target object in 3D API. Only relevant if fSurfaceType is
552 * kRenderTarget or kTextureRenderTarget
553 * GL: this is a FBO object (glGenFramebuffers)
554 */
555 GrPlatform3DObject fPlatformRenderTarget;
556 /**
557 * 3D API object used as destination of resolve. Only relevant if
558 * fSurfaceType is kRenderTarget or kTextureRenderTarget and
559 * kGrCanResolve is set in fRenderTargetFlags.
560 * fFlags.
561 * GL: this is a FBO object (glGenFramebuffers)
562 */
563 GrPlatform3DObject fPlatformResolveDestination;
564
resetGrPlatformSurfaceDesc565 void reset() { memset(this, 0, sizeof(GrPlatformSurfaceDesc)); }
566 };
567
568 /**
569 * Example of how to wrap render-to-texture-with-MSAA GL objects with a GrPlatformSurace
570 *
571 * GLint colorBufferID;
572 * glGenRenderbuffers(1, &colorID);
573 * glBindRenderbuffer(GL_RENDERBUFFER, colorBufferID);
574 * glRenderbufferStorageMultisample(GL_RENDERBUFFER, S, GL_RGBA, W, H);
575 *
576 * GLint stencilBufferID;
577 * glGenRenderBuffers(1, &stencilBufferID);
578 * glBindRenderbuffer(GL_RENDERBUFFER, stencilBufferID);
579 * glRenderbufferStorageMultisample(GL_RENDERBUFFER, S, GL_STENCIL_INDEX8, W, H);
580 *
581 * GLint drawFBOID;
582 * glGenFramebuffers(1, &drawFBOID);
583 * glBindFramebuffer(GL_FRAMEBUFFER, drawFBOID);
584 * glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorBufferID);
585 * glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, stencilBufferID);
586 *
587 * GLint textureID;
588 * glGenTextures(1, &textureID);
589 * glBindTexture(GL_TEXTURE_2D, textureID);
590 * glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, W, H, ...);
591 *
592 * GLint readFBOID;
593 * glGenFramebuffers(1, &readFBOID);
594 * glBindFramebuffer(GL_FRAMEBUFFER, readFBOID);
595 * glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, textureID, 0);
596 *
597 * GrPlatformSurfaceDesc renderTargetTextureDesc;
598 * renderTargetTextureDesc.fSurfaceType = kTextureRenderTarget_GrPlatformSurfaceType;
599 * renderTargetTextureDesc.fRenderTargetFlags = (kIsMultisampled_GrPlatformRenderTargetFlagBit | kGrCanResolve_GrPlatformRenderTargetFlagBit);
600 * renderTargetTextureDesc.fWidth = W;
601 * renderTargetTextureDesc.fHeight = H;
602 * renderTargetTextureDesc.fConfig = kRGBA_8888_GrPixelConfig
603 * renderTargetTextureDesc.fStencilBits = 8;
604 * renderTargetTextureDesc.fPlatformTexture = textureID;
605 * renderTargetTextureDesc.fPlatformRenderTarget = drawFBOID;
606 * renderTargetTextureDesc.fPlatformResolveDestination = readFBOID;
607 *
608 * GrTexture* texture = static_cast<GrTexture*>(grContext->createPlatrformSurface(renderTargetTextureDesc));
609 */
610
611
612 ///////////////////////////////////////////////////////////////////////////////
613
614 // this is included only to make it easy to use this debugging facility
615 #include "GrInstanceCounter.h"
616
617 #endif
618