Home | History | Annotate | Download | only in gpu
      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_STROKE_PATH_RENDERING controls whether or not the GrStrokePathRenderer can be selected
    217  * as a path renderer. GrStrokePathRenderer is currently an experimental path renderer.
    218  */
    219 #if !defined(GR_STROKE_PATH_RENDERING)
    220     #define GR_STROKE_PATH_RENDERING                 0
    221 #endif
    222 
    223 /**
    224  * GR_ALWAYS_ALLOCATE_ON_HEAP determines whether various temporary buffers created
    225  * in the GPU backend are always allocated on the heap or are allowed to be
    226  * allocated on the stack for smaller memory requests.
    227  *
    228  * This is only used for memory buffers that are created and then passed through to the
    229  * 3D API (e.g. as texture or geometry data)
    230  */
    231 #if !defined(GR_ALWAYS_ALLOCATE_ON_HEAP)
    232     #define GR_ALWAYS_ALLOCATE_ON_HEAP 0
    233 #endif
    234 
    235 /**
    236  * GR_FORCE_GPU_TRACE_DEBUGGING will force gpu tracing/debug markers to be turned on. The trace
    237  * markers will be printed out instead of making the backend calls to push and pop them.
    238  */
    239 #if !defined(GR_FORCE_GPU_TRACE_DEBUGGING)
    240     #define GR_FORCE_GPU_TRACE_DEBUGGING 0
    241 #endif
    242 
    243 #endif
    244