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