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. 48typedef signed char int8_t; 49typedef unsigned char uint8_t; 50typedef short int16_t; 51typedef unsigned short uint16_t; 52typedef int int32_t; 53typedef unsigned uint32_t; 54typedef __int64 int64_t; 55typedef 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 252