src/third_party/skia/include/gpu/GrConfig.h

   1
   2 /*
   3  * Copyright 2010 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9
  10
  11 #ifndef GrConfig_DEFINED
  12 #define GrConfig_DEFINED
  13
  14 #include "SkTypes.h"
  15
  16 ///////////////////////////////////////////////////////////////////////////////
  17 // preconfig section:
  18 //
  19 // All the work before including GrUserConfig.h should center around guessing
  20 // what platform we're on, and defining low-level symbols based on that.
  21 //
  22 // A build environment may have already defined symbols, so we first check
  23 // for that
  24 //
  25
  26 // hack to ensure we know what sort of Apple platform we're on
  27 #if defined(__APPLE_CPP__) || defined(__APPLE_CC__)
  28     #include <TargetConditionals.h>
  29 #endif
  30
  31 /**
  32  *  Gr defines are set to 0 or 1, rather than being undefined or defined
  33  */
  34
  35 #if !defined(GR_CACHE_STATS)
  36     #define GR_CACHE_STATS      0
  37 #endif
  38
  39 #if !defined(GR_GPU_STATS)
  40 #define GR_GPU_STATS      0
  41 #endif
  42
  43 ///////////////////////////////////////////////////////////////////////////////
  44 ///////////////////////////////////////////////////////////////////////////////
  45
  46 #if defined(SK_BUILD_FOR_WIN32)
  47 // VC8 doesn't support stdint.h, so we define those types here.
  48 typedef signed char int8_t;
  49 typedef unsigned char uint8_t;
  50 typedef short int16_t;
  51 typedef unsigned short uint16_t;
  52 typedef int int32_t;
  53 typedef unsigned uint32_t;
  54 typedef __int64 int64_t;
  55 typedef unsigned __int64 uint64_t;
  56 #else
  57 /*
  58  *  Include stdint.h with defines that trigger declaration of C99 limit/const
  59  *  macros here before anyone else has a chance to include stdint.h without
  60  *  these.
  61  */
  62 #ifndef __STDC_LIMIT_MACROS
  63 #define __STDC_LIMIT_MACROS
  64 #endif
  65 #ifndef __STDC_CONSTANT_MACROS
  66 #define __STDC_CONSTANT_MACROS
  67 #endif
  68 #include <stdint.h>
  69 #endif
  70
  71 /*
  72  *  The "user config" file can be empty, and everything should work. It is
  73  *  meant to store a given platform/client's overrides of our guess-work.
  74  *
  75  *  A alternate user config file can be specified by defining
  76  *  GR_USER_CONFIG_FILE. It should be defined relative to GrConfig.h
  77  *
  78  *  e.g. it can change the BUILD target or supply its own defines for anything
  79  *  else (e.g. GR_DEFAULT_RESOURCE_CACHE_MB_LIMIT)
  80  */
  81 #if !defined(GR_USER_CONFIG_FILE)
  82     #include "GrUserConfig.h"
  83 #else
  84     #include GR_USER_CONFIG_FILE
  85 #endif
  86
  87
  88 ///////////////////////////////////////////////////////////////////////////////
  89 ///////////////////////////////////////////////////////////////////////////////
  90 // postconfig section:
  91 //
  92
  93 // By now we must have a GR_..._BUILD symbol set to 1, and a decision about
  94 // debug -vs- release
  95 //
  96
  97 #define GrPrintf SkDebugf
  98
  99 /**
 100  *  GR_STRING makes a string of X where X is expanded before conversion to a string
 101  *  if X itself contains macros.
 102  */
 103 #define GR_STRING(X) GR_STRING_IMPL(X)
 104 #define GR_STRING_IMPL(X) #X
 105
 106 /**
 107  *  GR_CONCAT concatenates X and Y  where each is expanded before
 108  *  contanenation if either contains macros.
 109  */
 110 #define GR_CONCAT(X,Y) GR_CONCAT_IMPL(X,Y)
 111 #define GR_CONCAT_IMPL(X,Y) X##Y
 112
 113 /**
 114  *  Creates a string of the form "<filename>(<linenumber>) : "
 115  */
 116 #define GR_FILE_AND_LINE_STR __FILE__ "(" GR_STRING(__LINE__) ") : "
 117
 118 /**
 119  *  Compilers have different ways of issuing warnings. This macro
 120  *  attempts to abstract them, but may need to be specialized for your
 121  *  particular compiler.
 122  *  To insert compiler warnings use "#pragma message GR_WARN(<string>)"
 123  */
 124 #if defined(_MSC_VER) && _MSC_VER
 125     #define GR_WARN(MSG) (GR_FILE_AND_LINE_STR "WARNING: " MSG)
 126 #else//__GNUC__ - may need other defines for different compilers
 127     #define GR_WARN(MSG) ("WARNING: " MSG)
 128 #endif
 129
 130 /**
 131  *  GR_ALWAYSBREAK is an unconditional break in all builds.
 132  */
 133 #if !defined(GR_ALWAYSBREAK)
 134     #if     defined(SK_BUILD_FOR_WIN32)
 135         #define GR_ALWAYSBREAK SkNO_RETURN_HINT(); __debugbreak()
 136     #else
 137         // TODO: do other platforms really not have continuable breakpoints?
 138         // sign extend for 64bit architectures to be sure this is
 139         // in the high address range
 140         #define GR_ALWAYSBREAK SkNO_RETURN_HINT(); *((int*)(int64_t)(int32_t)0xbeefcafe) = 0;
 141     #endif
 142 #endif
 143
 144 /**
 145  *  GR_DEBUGBREAK is an unconditional break in debug builds.
 146  */
 147 #if !defined(GR_DEBUGBREAK)
 148     #ifdef SK_DEBUG
 149         #define GR_DEBUGBREAK GR_ALWAYSBREAK
 150     #else
 151         #define GR_DEBUGBREAK
 152     #endif
 153 #endif
 154
 155 /**
 156  *  GR_ALWAYSASSERT is an assertion in all builds.
 157  */
 158 #if !defined(GR_ALWAYSASSERT)
 159     #define GR_ALWAYSASSERT(COND)                                        \
 160         do {                                                             \
 161             if (!(COND)) {                                               \
 162                 GrPrintf("%s %s failed\n", GR_FILE_AND_LINE_STR, #COND); \
 163                 GR_ALWAYSBREAK;                                          \
 164             }                                                            \
 165         } while (false)
 166 #endif
 167
 168 /**
 169  *  GR_DEBUGASSERT is an assertion in debug builds only.
 170  */
 171 #if !defined(GR_DEBUGASSERT)
 172     #ifdef SK_DEBUG
 173         #define GR_DEBUGASSERT(COND) GR_ALWAYSASSERT(COND)
 174     #else
 175         #define GR_DEBUGASSERT(COND)
 176     #endif
 177 #endif
 178
 179 /**
 180  *  Prettier forms of the above macros.
 181  */
 182 #define GrAlwaysAssert(COND) GR_ALWAYSASSERT(COND)
 183
 184 /**
 185  *  GR_STATIC_ASSERT is a compile time assertion. Depending on the platform
 186  *  it may print the message in the compiler log. Obviously, the condition must
 187  *  be evaluatable at compile time.
 188  */
 189 // VS 2010 and GCC compiled with c++0x or gnu++0x support the new
 190 // static_assert.
 191 #if !defined(GR_STATIC_ASSERT)
 192     #if (defined(_MSC_VER) && _MSC_VER >= 1600) || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)
 193         #define GR_STATIC_ASSERT(CONDITION) static_assert(CONDITION, "bug")
 194     #else
 195         template <bool> class GR_STATIC_ASSERT_FAILURE;
 196         template <> class GR_STATIC_ASSERT_FAILURE<true> {};
 197         #define GR_STATIC_ASSERT(CONDITION) \
 198             enum {GR_CONCAT(X,__LINE__) = \
 199             sizeof(GR_STATIC_ASSERT_FAILURE<CONDITION>)}
 200     #endif
 201 #endif
 202
 203 /**
 204  * GR_GEOM_BUFFER_MAP_THRESHOLD gives a threshold (in bytes) for when Gr should
 205  * map a GrGeometryBuffer to update its contents. It will use map() if the
 206  * size of the updated region is greater than the threshold. Otherwise it will
 207  * use updateData().
 208  */
 209 #if !defined(GR_GEOM_BUFFER_MAP_THRESHOLD)
 210     #define GR_GEOM_BUFFER_MAP_THRESHOLD (1 << 15)
 211 #endif
 212
 213 /**
 214  * GR_DEFAULT_RESOURCE_CACHE_MB_LIMIT gives a threshold (in megabytes) for the
 215  * maximum size of the texture cache in vram. The value is only a default and
 216  * can be overridden at runtime.
 217  */
 218 #if !defined(GR_DEFAULT_RESOURCE_CACHE_MB_LIMIT)
 219     #define GR_DEFAULT_RESOURCE_CACHE_MB_LIMIT 96
 220 #endif
 221
 222 /**
 223  * GR_DEFAULT_RESOURCE_CACHE_COUNT_LIMIT specifies the maximum number of
 224  * textures the texture cache can hold in vram. The value is only a default and
 225  * can be overridden at runtime.
 226  */
 227 #if !defined(GR_DEFAULT_RESOURCE_CACHE_COUNT_LIMIT)
 228     #define GR_DEFAULT_RESOURCE_CACHE_COUNT_LIMIT 2048
 229 #endif
 230
 231 /**
 232  * GR_STROKE_PATH_RENDERING controls whether or not the GrStrokePathRenderer can be selected
 233  * as a path renderer. GrStrokePathRenderer is currently an experimental path renderer.
 234  */
 235 #if !defined(GR_STROKE_PATH_RENDERING)
 236     #define GR_STROKE_PATH_RENDERING                 0
 237 #endif
 238
 239 /**
 240  * GR_ALWAYS_ALLOCATE_ON_HEAP determines whether various temporary buffers created
 241  * in the GPU backend are always allocated on the heap or are allowed to be
 242  * allocated on the stack for smaller memory requests.
 243  *
 244  * This is only used for memory buffers that are created and then passed through to the
 245  * 3D API (e.g. as texture or geometry data)
 246  */
 247 #if !defined(GR_ALWAYS_ALLOCATE_ON_HEAP)
 248     #define GR_ALWAYS_ALLOCATE_ON_HEAP 0
 249 #endif
 250
 251 #endif