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 ///////////////////////////////////////////////////////////////////////////////
15 // preconfig section:
16 //
17 // All the work before including GrUserConfig.h should center around guessing
18 // what platform we're on, and defining low-level symbols based on that.
19 //
20 // A build environment may have already defined symbols, so we first check
21 // for that
22 //
23
24 // hack to ensure we know what sort of Apple platform we're on
25 #if defined(__APPLE_CPP__) || defined(__APPLE_CC__)
26 #include <TargetConditionals.h>
27 #endif
28
29 /**
30 * Gr defines are set to 0 or 1, rather than being undefined or defined
31 */
32
33 #if !defined(GR_ANDROID_BUILD)
34 #define GR_ANDROID_BUILD 0
35 #endif
36 #if !defined(GR_IOS_BUILD)
37 #define GR_IOS_BUILD 0
38 #endif
39 #if !defined(GR_LINUX_BUILD)
40 #define GR_LINUX_BUILD 0
41 #endif
42 #if !defined(GR_MAC_BUILD)
43 #define GR_MAC_BUILD 0
44 #endif
45 #if !defined(GR_WIN32_BUILD)
46 #define GR_WIN32_BUILD 0
47 #endif
48 #if !defined(GR_QNX_BUILD)
49 #define GR_QNX_BUILD 0
50 #endif
51
52 /**
53 * If no build target has been defined, attempt to infer.
54 */
55 #if !GR_ANDROID_BUILD && !GR_IOS_BUILD && !GR_LINUX_BUILD && !GR_MAC_BUILD && !GR_WIN32_BUILD && !GR_QNX_BUILD
56 #if defined(_WIN32)
57 #undef GR_WIN32_BUILD
58 #define GR_WIN32_BUILD 1
59 // #error "WIN"
60 #elif TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
61 #undef GR_IOS_BUILD
62 #define GR_IOS_BUILD 1
63 // #error "IOS"
64 #elif defined(SK_BUILD_FOR_ANDROID)
65 #undef GR_ANDROID_BUILD
66 #define GR_ANDROID_BUILD 1
67 // #error "ANDROID"
68 #elif TARGET_OS_MAC
69 #undef GR_MAC_BUILD
70 #define GR_MAC_BUILD 1
71 // #error "MAC"
72 #elif TARGET_OS_QNX || defined(__QNXNTO__)
73 #undef GR_QNX_BUILD
74 #define GR_QNX_BUILD 1
75 // #error "QNX"
76 #else
77 #undef GR_LINUX_BUILD
78 #define GR_LINUX_BUILD 1
79 // #error "LINUX"
80 #endif
81 #endif
82
83 // we need both GR_DEBUG and GR_RELEASE to be defined as 0 or 1
84 //
85 #ifndef GR_DEBUG
86 #ifdef GR_RELEASE
87 #define GR_DEBUG !GR_RELEASE
88 #else
89 #ifdef NDEBUG
90 #define GR_DEBUG 0
91 #else
92 #define GR_DEBUG 1
93 #endif
94 #endif
95 #endif
96
97 #ifndef GR_RELEASE
98 #define GR_RELEASE !GR_DEBUG
99 #endif
100
101 #if GR_DEBUG == GR_RELEASE
102 #error "GR_DEBUG and GR_RELEASE must not be the same"
103 #endif
104
105 ///////////////////////////////////////////////////////////////////////////////
106 ///////////////////////////////////////////////////////////////////////////////
107
108 #if GR_WIN32_BUILD
109 // VC8 doesn't support stdint.h, so we define those types here.
110 typedef signed char int8_t;
111 typedef unsigned char uint8_t;
112 typedef short int16_t;
113 typedef unsigned short uint16_t;
114 typedef int int32_t;
115 typedef unsigned uint32_t;
116 typedef __int64 int64_t;
117 typedef unsigned __int64 uint64_t;
118 #else
119 /*
120 * Include stdint.h with defines that trigger declaration of C99 limit/const
121 * macros here before anyone else has a chance to include stdint.h without
122 * these.
123 */
124 #define __STDC_LIMIT_MACROS
125 #define __STDC_CONSTANT_MACROS
126 #include <stdint.h>
127 #endif
128
129 /*
130 * The "user config" file can be empty, and everything should work. It is
131 * meant to store a given platform/client's overrides of our guess-work.
132 *
133 * A alternate user config file can be specified by defining
134 * GR_USER_CONFIG_FILE. It should be defined relative to GrConfig.h
135 *
136 * e.g. it can specify GR_DEBUG/GR_RELEASE as it please, change the BUILD
137 * target, or supply its own defines for anything else (e.g. GR_SCALAR)
138 */
139 #if !defined(GR_USER_CONFIG_FILE)
140 #include "GrUserConfig.h"
141 #else
142 #include GR_USER_CONFIG_FILE
143 #endif
144
145
146 ///////////////////////////////////////////////////////////////////////////////
147 ///////////////////////////////////////////////////////////////////////////////
148 // postconfig section:
149 //
150
151 // GR_IMPLEMENTATION should be define to 1 when building Gr and 0 when including
152 // it in another dependent build. The Gr makefile/ide-project should define this
153 // to 1.
154 #if !defined(GR_IMPLEMENTATION)
155 #define GR_IMPLEMENTATION 0
156 #endif
157
158 // If Gr is built as a shared library then GR_DLL should be defined to 1 (both
159 // when building Gr and when including its headers in dependent builds). Only
160 // currently supported minimally for Chrome's Win32 Multi-DLL build (TODO:
161 // correctly exort all of the public API correctly and support shared lib on
162 // other platforms).
163 #if !defined(GR_DLL)
164 #define GR_DLL 0
165 #endif
166
167 #if GR_DLL
168 #if GR_WIN32_BUILD
169 #if GR_IMPLEMENTATION
170 #define GR_API __declspec(dllexport)
171 #else
172 #define GR_API __declspec(dllimport)
173 #endif
174 #else
175 #define GR_API __attribute__((visibility("default")))
176 #endif
177 #else
178 #define GR_API
179 #endif
180
181 // By now we must have a GR_..._BUILD symbol set to 1, and a decision about
182 // debug -vs- release
183 //
184
185 extern GR_API void GrPrintf(const char format[], ...);
186
187 /**
188 * GR_STRING makes a string of X where X is expanded before conversion to a string
189 * if X itself contains macros.
190 */
191 #define GR_STRING(X) GR_STRING_IMPL(X)
192 #define GR_STRING_IMPL(X) #X
193
194 /**
195 * GR_CONCAT concatenates X and Y where each is expanded before
196 * contanenation if either contains macros.
197 */
198 #define GR_CONCAT(X,Y) GR_CONCAT_IMPL(X,Y)
199 #define GR_CONCAT_IMPL(X,Y) X##Y
200
201 /**
202 * Creates a string of the form "<filename>(<linenumber>) : "
203 */
204 #define GR_FILE_AND_LINE_STR __FILE__ "(" GR_STRING(__LINE__) ") : "
205
206 /**
207 * Compilers have different ways of issuing warnings. This macro
208 * attempts to abstract them, but may need to be specialized for your
209 * particular compiler.
210 * To insert compiler warnings use "#pragma message GR_WARN(<string>)"
211 */
212 #if defined(_MSC_VER) && _MSC_VER
213 #define GR_WARN(MSG) (GR_FILE_AND_LINE_STR "WARNING: " MSG)
214 #else//__GNUC__ - may need other defines for different compilers
215 #define GR_WARN(MSG) ("WARNING: " MSG)
216 #endif
217
218 /**
219 * GR_ALWAYSBREAK is an unconditional break in all builds.
220 */
221 #if !defined(GR_ALWAYSBREAK)
222 #if GR_WIN32_BUILD
223 #define GR_ALWAYSBREAK SkNO_RETURN_HINT(); __debugbreak()
224 #else
225 // TODO: do other platforms really not have continuable breakpoints?
226 // sign extend for 64bit architectures to be sure this is
227 // in the high address range
228 #define GR_ALWAYSBREAK SkNO_RETURN_HINT(); *((int*)(int64_t)(int32_t)0xbeefcafe) = 0;
229 #endif
230 #endif
231
232 /**
233 * GR_DEBUGBREAK is an unconditional break in debug builds.
234 */
235 #if !defined(GR_DEBUGBREAK)
236 #if GR_DEBUG
237 #define GR_DEBUGBREAK GR_ALWAYSBREAK
238 #else
239 #define GR_DEBUGBREAK
240 #endif
241 #endif
242
243 /**
244 * GR_ALWAYSASSERT is an assertion in all builds.
245 */
246 #if !defined(GR_ALWAYSASSERT)
247 #define GR_ALWAYSASSERT(COND) \
248 do { \
249 if (!(COND)) { \
250 GrPrintf("%s %s failed\n", GR_FILE_AND_LINE_STR, #COND); \
251 GR_ALWAYSBREAK; \
252 } \
253 } while (false)
254 #endif
255
256 /**
257 * GR_DEBUGASSERT is an assertion in debug builds only.
258 */
259 #if !defined(GR_DEBUGASSERT)
260 #if GR_DEBUG
261 #define GR_DEBUGASSERT(COND) GR_ALWAYSASSERT(COND)
262 #else
263 #define GR_DEBUGASSERT(COND)
264 #endif
265 #endif
266
267 /**
268 * Prettier forms of the above macros.
269 */
270 #define GrAssert(COND) GR_DEBUGASSERT(COND)
271 #define GrAlwaysAssert(COND) GR_ALWAYSASSERT(COND)
272
273 /**
274 * Crash from unrecoverable condition, optionally with a message.
275 */
GrCrash()276 inline void GrCrash() { GrAlwaysAssert(false); }
GrCrash(const char * msg)277 inline void GrCrash(const char* msg) { GrPrintf(msg); GrAlwaysAssert(false); }
278
279 /**
280 * GR_DEBUGCODE compiles the code X in debug builds only
281 */
282 #if !defined(GR_DEBUGCODE)
283 #if GR_DEBUG
284 #define GR_DEBUGCODE(X) X
285 #else
286 #define GR_DEBUGCODE(X)
287 #endif
288 #endif
289
290 /**
291 * GR_STATIC_ASSERT is a compile time assertion. Depending on the platform
292 * it may print the message in the compiler log. Obviously, the condition must
293 * be evaluatable at compile time.
294 */
295 // VS 2010 and GCC compiled with c++0x or gnu++0x support the new
296 // static_assert.
297 #if !defined(GR_STATIC_ASSERT)
298 #if (defined(_MSC_VER) && _MSC_VER >= 1600) || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)
299 #define GR_STATIC_ASSERT(CONDITION) static_assert(CONDITION, "bug")
300 #else
301 template <bool> class GR_STATIC_ASSERT_FAILURE;
302 template <> class GR_STATIC_ASSERT_FAILURE<true> {};
303 #define GR_STATIC_ASSERT(CONDITION) \
304 enum {GR_CONCAT(X,__LINE__) = \
305 sizeof(GR_STATIC_ASSERT_FAILURE<CONDITION>)}
306 #endif
307 #endif
308
309 #if !defined(GR_SCALAR_IS_FLOAT)
310 #define GR_SCALAR_IS_FLOAT 0
311 #endif
312 #if !defined(GR_SCALAR_IS_FIXED)
313 #define GR_SCALAR_IS_FIXED 0
314 #endif
315
316 #if !defined(GR_TEXT_SCALAR_TYPE_IS_USHORT)
317 #define GR_TEXT_SCALAR_TYPE_IS_USHORT 0
318 #endif
319 #if !defined(GR_TEXT_SCALAR_TYPE_IS_FLOAT)
320 #define GR_TEXT_SCALAR_TYPE_IS_FLOAT 0
321 #endif
322 #if !defined(GR_TEXT_SCALAR_TYPE_IS_FIXED)
323 #define GR_TEXT_SCALAR_TYPE_IS_FIXED 0
324 #endif
325
326 #ifndef GR_DUMP_TEXTURE_UPLOAD
327 #define GR_DUMP_TEXTURE_UPLOAD 0
328 #endif
329
330 /**
331 * GR_COLLECT_STATS controls whether the GrGpu class collects stats.
332 * If not already defined then collect in debug build but not release.
333 */
334 #if !defined(GR_COLLECT_STATS)
335 #define GR_COLLECT_STATS GR_DEBUG
336 #endif
337
338 /**
339 * GR_STATIC_RECT_VB controls whether rects are drawn by issuing a vertex
340 * for each corner or using a static vb that is positioned by modifying the
341 * view / texture matrix.
342 */
343 #if !defined(GR_STATIC_RECT_VB)
344 #define GR_STATIC_RECT_VB 0
345 #endif
346
347 /**
348 * GR_AGGRESSIVE_SHADER_OPTS controls how aggressively shaders are optimized
349 * for special cases. On systems where program changes are expensive this
350 * may not be advantageous. Consecutive draws may no longer use the same
351 * program.
352 */
353 #if !defined(GR_AGGRESSIVE_SHADER_OPTS)
354 #define GR_AGGRESSIVE_SHADER_OPTS 1
355 #endif
356
357 /**
358 * GR_GEOM_BUFFER_LOCK_THRESHOLD gives a threshold (in bytes) for when Gr should
359 * lock a GrGeometryBuffer to update its contents. It will use lock() if the
360 * size of the updated region is greater than the threshold. Otherwise it will
361 * use updateData().
362 */
363 #if !defined(GR_GEOM_BUFFER_LOCK_THRESHOLD)
364 #define GR_GEOM_BUFFER_LOCK_THRESHOLD (1 << 15)
365 #endif
366
367 ///////////////////////////////////////////////////////////////////////////////
368 // tail section:
369 //
370 // Now we just assert if we are missing some required define, or if we detect
371 // and inconsistent combination of defines
372 //
373
374
375 /**
376 * Only one build target macro should be 1 and the rest should be 0.
377 */
378 #define GR_BUILD_SUM (GR_WIN32_BUILD + GR_MAC_BUILD + GR_IOS_BUILD + GR_ANDROID_BUILD + GR_LINUX_BUILD + GR_QNX_BUILD)
379 #if 0 == GR_BUILD_SUM
380 #error "Missing a GR_BUILD define"
381 #elif 1 != GR_BUILD_SUM
382 #error "More than one GR_BUILD defined"
383 #endif
384
385
386 #if !GR_SCALAR_IS_FLOAT && !GR_SCALAR_IS_FIXED
387 #undef GR_SCALAR_IS_FLOAT
388 #define GR_SCALAR_IS_FLOAT 1
389 #pragma message GR_WARN("Scalar type not defined, defaulting to float")
390 #endif
391
392 #if !GR_TEXT_SCALAR_IS_FLOAT && \
393 !GR_TEXT_SCALAR_IS_FIXED && \
394 !GR_TEXT_SCALAR_IS_USHORT
395 #undef GR_TEXT_SCALAR_IS_FLOAT
396 #define GR_TEXT_SCALAR_IS_FLOAT 1
397 #pragma message GR_WARN("Text scalar type not defined, defaulting to float")
398 #endif
399
400 #if 0
401 #if GR_WIN32_BUILD
402 // #pragma message GR_WARN("GR_WIN32_BUILD")
403 #endif
404 #if GR_MAC_BUILD
405 // #pragma message GR_WARN("GR_MAC_BUILD")
406 #endif
407 #if GR_IOS_BUILD
408 // #pragma message GR_WARN("GR_IOS_BUILD")
409 #endif
410 #if GR_ANDROID_BUILD
411 // #pragma message GR_WARN("GR_ANDROID_BUILD")
412 #endif
413 #if GR_LINUX_BUILD
414 // #pragma message GR_WARN("GR_LINUX_BUILD")
415 #endif
416 #if GR_QNX_BUILD
417 // #pragma message GR_WARN("GR_QNX_BUILD")
418 #endif
419 #endif
420
421 #endif
422
423