2008-04-25 13:37:36 +00:00
|
|
|
/*
|
2009-04-27 14:48:12 +00:00
|
|
|
* Cogl
|
2008-04-25 13:37:36 +00:00
|
|
|
*
|
2009-04-27 14:48:12 +00:00
|
|
|
* An object oriented GL/GLES Abstraction/Utility Layer
|
2008-04-25 13:37:36 +00:00
|
|
|
*
|
2010-02-11 14:20:48 +00:00
|
|
|
* Copyright (C) 2007,2008,2009,2010 Intel Corporation.
|
2008-04-25 13:37:36 +00:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2010-03-01 12:56:10 +00:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __COGL_UTIL_H
|
|
|
|
#define __COGL_UTIL_H
|
|
|
|
|
2010-02-11 14:20:48 +00:00
|
|
|
#include <glib.h>
|
|
|
|
#include <math.h>
|
2012-02-18 01:19:17 +00:00
|
|
|
|
|
|
|
#include <cogl/cogl-defines.h>
|
2012-02-17 20:44:28 +00:00
|
|
|
#include "cogl-types.h"
|
2010-02-11 14:20:48 +00:00
|
|
|
|
2011-10-13 21:34:30 +00:00
|
|
|
#ifndef COGL_HAS_GLIB_SUPPORT
|
|
|
|
#include <stdio.h>
|
|
|
|
#endif
|
|
|
|
|
2012-04-16 16:23:15 +00:00
|
|
|
/* Double check that config.h has been included */
|
|
|
|
#if !defined (GETTEXT_PACKAGE) && !defined (_COGL_IN_TEST_BITMASK)
|
|
|
|
#error "config.h must be included before including cogl-util.h"
|
|
|
|
#endif
|
|
|
|
|
2011-11-24 16:09:16 +00:00
|
|
|
/* When compiling with Visual Studio, symbols that represent data that
|
|
|
|
are exported out of the DLL need to be marked with the dllexport
|
|
|
|
attribute. */
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
#ifdef COGL_BUILD_EXP
|
|
|
|
#define COGL_EXPORT __declspec(dllexport)
|
|
|
|
#else
|
|
|
|
#define COGL_EXPORT __declspec(dllimport)
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
#define COGL_EXPORT
|
|
|
|
#endif
|
|
|
|
|
2009-04-27 14:48:12 +00:00
|
|
|
int
|
2010-09-15 13:39:05 +00:00
|
|
|
_cogl_util_next_p2 (int a);
|
2008-04-25 13:37:36 +00:00
|
|
|
|
2010-02-11 14:20:48 +00:00
|
|
|
/* The signbit macro is defined by ISO C99 so it should be available,
|
|
|
|
however if it's not we can fallback to an evil hack */
|
|
|
|
#ifdef signbit
|
|
|
|
#define cogl_util_float_signbit(x) signbit(x)
|
|
|
|
#else
|
|
|
|
/* This trick was stolen from here:
|
|
|
|
http://lists.boost.org/Archives/boost/2006/08/108731.php
|
|
|
|
|
|
|
|
It xors the integer reinterpretations of -1.0f and 1.0f. In theory
|
|
|
|
they should only differ by the signbit so that gives a mask for the
|
|
|
|
sign which we can just test against the value */
|
Switch use of primitive glib types to c99 equivalents
The coding style has for a long time said to avoid using redundant glib
data types such as gint or gchar etc because we feel that they make the
code look unnecessarily foreign to developers coming from outside of the
Gnome developer community.
Note: When we tried to find the historical rationale for the types we
just found that they were apparently only added for consistent syntax
highlighting which didn't seem that compelling.
Up until now we have been continuing to use some of the platform
specific type such as gint{8,16,32,64} and gsize but this patch switches
us over to using the standard c99 equivalents instead so we can further
ensure that our code looks familiar to the widest range of C developers
who might potentially contribute to Cogl.
So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this
switches all Cogl code to instead use the int{8,16,32,64}_t and
uint{8,16,32,64}_t c99 types instead.
Instead of gsize we now use size_t
For now we are not going to use the c99 _Bool type and instead we have
introduced a new CoglBool type to use instead of gboolean.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
(cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
|
|
|
static inline CoglBool
|
2010-02-11 14:20:48 +00:00
|
|
|
cogl_util_float_signbit (float x)
|
|
|
|
{
|
Switch use of primitive glib types to c99 equivalents
The coding style has for a long time said to avoid using redundant glib
data types such as gint or gchar etc because we feel that they make the
code look unnecessarily foreign to developers coming from outside of the
Gnome developer community.
Note: When we tried to find the historical rationale for the types we
just found that they were apparently only added for consistent syntax
highlighting which didn't seem that compelling.
Up until now we have been continuing to use some of the platform
specific type such as gint{8,16,32,64} and gsize but this patch switches
us over to using the standard c99 equivalents instead so we can further
ensure that our code looks familiar to the widest range of C developers
who might potentially contribute to Cogl.
So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this
switches all Cogl code to instead use the int{8,16,32,64}_t and
uint{8,16,32,64}_t c99 types instead.
Instead of gsize we now use size_t
For now we are not going to use the c99 _Bool type and instead we have
introduced a new CoglBool type to use instead of gboolean.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
(cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
|
|
|
static const union { float f; uint32_t i; } negative_one = { -1.0f };
|
|
|
|
static const union { float f; uint32_t i; } positive_one = { +1.0f };
|
|
|
|
union { float f; uint32_t i; } value = { x };
|
2010-02-11 14:20:48 +00:00
|
|
|
|
|
|
|
return !!((negative_one.i ^ positive_one.i) & value.i);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-02-17 15:58:32 +00:00
|
|
|
/* This is a replacement for the nearbyint function which always
|
|
|
|
rounds to the nearest integer. nearbyint is apparently a C99
|
|
|
|
function so it might not always be available but also it seems in
|
|
|
|
glibc it is defined as a function call so this macro could end up
|
|
|
|
faster anyway. We can't just add 0.5f because it will break for
|
|
|
|
negative numbers. */
|
|
|
|
#define COGL_UTIL_NEARBYINT(x) ((int) ((x) < 0.0f ? (x) - 0.5f : (x) + 0.5f))
|
|
|
|
|
2010-07-01 10:07:03 +00:00
|
|
|
/* Returns whether the given integer is a power of two */
|
Switch use of primitive glib types to c99 equivalents
The coding style has for a long time said to avoid using redundant glib
data types such as gint or gchar etc because we feel that they make the
code look unnecessarily foreign to developers coming from outside of the
Gnome developer community.
Note: When we tried to find the historical rationale for the types we
just found that they were apparently only added for consistent syntax
highlighting which didn't seem that compelling.
Up until now we have been continuing to use some of the platform
specific type such as gint{8,16,32,64} and gsize but this patch switches
us over to using the standard c99 equivalents instead so we can further
ensure that our code looks familiar to the widest range of C developers
who might potentially contribute to Cogl.
So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this
switches all Cogl code to instead use the int{8,16,32,64}_t and
uint{8,16,32,64}_t c99 types instead.
Instead of gsize we now use size_t
For now we are not going to use the c99 _Bool type and instead we have
introduced a new CoglBool type to use instead of gboolean.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
(cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
|
|
|
static inline CoglBool
|
2010-07-01 10:07:03 +00:00
|
|
|
_cogl_util_is_pot (unsigned int num)
|
|
|
|
{
|
|
|
|
/* Make sure there is only one bit set */
|
|
|
|
return (num & (num - 1)) == 0;
|
|
|
|
}
|
|
|
|
|
2010-11-04 13:57:36 +00:00
|
|
|
/* Split Bob Jenkins' One-at-a-Time hash
|
|
|
|
*
|
|
|
|
* This uses the One-at-a-Time hash algorithm designed by Bob Jenkins
|
|
|
|
* but the mixing step is split out so the function can be used in a
|
|
|
|
* more incremental fashion.
|
|
|
|
*/
|
|
|
|
static inline unsigned int
|
|
|
|
_cogl_util_one_at_a_time_hash (unsigned int hash,
|
2012-04-04 21:20:04 +00:00
|
|
|
const void *key,
|
2010-11-04 13:57:36 +00:00
|
|
|
size_t bytes)
|
|
|
|
{
|
2012-04-04 21:20:04 +00:00
|
|
|
const unsigned char *p = key;
|
2010-11-04 13:57:36 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < bytes; i++)
|
|
|
|
{
|
|
|
|
hash += p[i];
|
|
|
|
hash += (hash << 10);
|
|
|
|
hash ^= (hash >> 6);
|
|
|
|
}
|
|
|
|
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int
|
|
|
|
_cogl_util_one_at_a_time_mix (unsigned int hash);
|
|
|
|
|
2011-11-01 13:10:59 +00:00
|
|
|
/* These two builtins are available since GCC 3.4 */
|
|
|
|
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
|
|
|
|
#define COGL_UTIL_HAVE_BUILTIN_FFSL
|
|
|
|
#define COGL_UTIL_HAVE_BUILTIN_POPCOUNTL
|
2012-11-09 17:55:54 +00:00
|
|
|
#define COGL_UTIL_HAVE_BUILTIN_CLZ
|
2011-11-01 13:10:59 +00:00
|
|
|
#endif
|
|
|
|
|
2010-12-17 16:06:10 +00:00
|
|
|
/* The 'ffs' function is part of C99 so it isn't always available */
|
|
|
|
#ifdef HAVE_FFS
|
|
|
|
#define _cogl_util_ffs ffs
|
|
|
|
#else
|
|
|
|
int
|
|
|
|
_cogl_util_ffs (int num);
|
|
|
|
#endif
|
|
|
|
|
2011-10-28 19:09:53 +00:00
|
|
|
/* The 'ffsl' function is non-standard but GCC has a builtin for it
|
|
|
|
since 3.4 which we can use */
|
2011-11-01 13:10:59 +00:00
|
|
|
#ifdef COGL_UTIL_HAVE_BUILTIN_FFSL
|
2011-10-28 19:09:53 +00:00
|
|
|
#define _cogl_util_ffsl __builtin_ffsl
|
|
|
|
#else
|
|
|
|
/* If ints and longs are the same size we can just use ffs. Hopefully
|
|
|
|
the compiler will optimise away this conditional */
|
|
|
|
#define _cogl_util_ffsl(x) \
|
|
|
|
(sizeof (long int) == sizeof (int) ? _cogl_util_ffs ((int) x) : \
|
|
|
|
_cogl_util_ffsl_wrapper (x))
|
|
|
|
int
|
|
|
|
_cogl_util_ffsl_wrapper (long int num);
|
2011-11-01 13:10:59 +00:00
|
|
|
#endif /* COGL_UTIL_HAVE_BUILTIN_FFSL */
|
|
|
|
|
2012-11-09 17:55:54 +00:00
|
|
|
static inline unsigned int
|
|
|
|
_cogl_util_fls (unsigned int n)
|
|
|
|
{
|
|
|
|
#ifdef COGL_UTIL_HAVE_BUILTIN_CLZ
|
|
|
|
return n == 0 ? 0 : sizeof (unsigned int) * 8 - __builtin_clz (n);
|
|
|
|
#else
|
|
|
|
unsigned int v = 1;
|
|
|
|
|
|
|
|
if (n == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
while (n >>= 1)
|
|
|
|
v++;
|
|
|
|
|
|
|
|
return v;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2011-11-01 13:10:59 +00:00
|
|
|
#ifdef COGL_UTIL_HAVE_BUILTIN_POPCOUNTL
|
|
|
|
#define _cogl_util_popcountl __builtin_popcountl
|
|
|
|
#else
|
|
|
|
extern const unsigned char _cogl_util_popcount_table[256];
|
|
|
|
|
|
|
|
/* There are many ways of doing popcount but doing a table lookup
|
|
|
|
seems to be the most robust against different sizes for long. Some
|
|
|
|
pages seem to claim it's the fastest method anyway. */
|
|
|
|
static inline int
|
|
|
|
_cogl_util_popcountl (unsigned long num)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int sum = 0;
|
|
|
|
|
|
|
|
/* Let's hope GCC will unroll this loop.. */
|
|
|
|
for (i = 0; i < sizeof (num); i++)
|
|
|
|
sum += _cogl_util_popcount_table[(num >> (i * 8)) & 0xff];
|
|
|
|
|
|
|
|
return sum;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* COGL_UTIL_HAVE_BUILTIN_POPCOUNTL */
|
2011-10-28 19:09:53 +00:00
|
|
|
|
2011-10-13 21:34:30 +00:00
|
|
|
#ifdef COGL_HAS_GLIB_SUPPORT
|
|
|
|
#define _COGL_RETURN_IF_FAIL(EXPR) g_return_if_fail(EXPR)
|
|
|
|
#define _COGL_RETURN_VAL_IF_FAIL(EXPR, VAL) g_return_val_if_fail(EXPR, VAL)
|
|
|
|
#else
|
2012-12-29 02:00:00 +00:00
|
|
|
#ifdef COGL_ENABLE_DEBUG
|
2012-05-17 13:51:43 +00:00
|
|
|
#define _COGL_RETURN_START do {
|
|
|
|
#define _COGL_RETURN_END } while (0)
|
|
|
|
#else /* COGL_ENABLE_DEBUG */
|
|
|
|
/* If debugging is disabled then we don't actually want to do the
|
|
|
|
* check but we still want the code for the expression to be generated
|
|
|
|
* so that it won't give loads of warnings about unused variables.
|
|
|
|
* Therefore we just surround the block with if(0) */
|
|
|
|
#define _COGL_RETURN_START do { if (0) {
|
|
|
|
#define _COGL_RETURN_END } } while (0)
|
|
|
|
#endif /* COGL_ENABLE_DEBUG */
|
|
|
|
#define _COGL_RETURN_IF_FAIL(EXPR) _COGL_RETURN_START { \
|
2011-10-13 21:34:30 +00:00
|
|
|
if (!(EXPR)) \
|
|
|
|
{ \
|
|
|
|
fprintf (stderr, "file %s: line %d: assertion `%s' failed", \
|
|
|
|
__FILE__, \
|
|
|
|
__LINE__, \
|
|
|
|
#EXPR); \
|
|
|
|
return; \
|
|
|
|
}; \
|
2012-05-17 13:51:43 +00:00
|
|
|
} _COGL_RETURN_END
|
|
|
|
#define _COGL_RETURN_VAL_IF_FAIL(EXPR, VAL) _COGL_RETURN_START { \
|
2011-10-13 21:34:30 +00:00
|
|
|
if (!(EXPR)) \
|
|
|
|
{ \
|
|
|
|
fprintf (stderr, "file %s: line %d: assertion `%s' failed", \
|
|
|
|
__FILE__, \
|
|
|
|
__LINE__, \
|
|
|
|
#EXPR); \
|
|
|
|
return (VAL); \
|
|
|
|
}; \
|
2012-05-17 13:51:43 +00:00
|
|
|
} _COGL_RETURN_END
|
2011-10-13 21:34:30 +00:00
|
|
|
#endif /* COGL_HAS_GLIB_SUPPORT */
|
|
|
|
|
2012-02-17 20:44:28 +00:00
|
|
|
/* Match a CoglPixelFormat according to channel masks, color depth,
|
|
|
|
* bits per pixel and byte order. These information are provided by
|
|
|
|
* the Visual and XImage structures.
|
|
|
|
*
|
|
|
|
* If no specific pixel format could be found, COGL_PIXEL_FORMAT_ANY
|
|
|
|
* is returned.
|
|
|
|
*/
|
|
|
|
CoglPixelFormat
|
|
|
|
_cogl_util_pixel_format_from_masks (unsigned long r_mask,
|
|
|
|
unsigned long g_mask,
|
|
|
|
unsigned long b_mask,
|
|
|
|
int depth, int bpp,
|
|
|
|
int byte_order);
|
|
|
|
|
2012-04-16 16:23:15 +00:00
|
|
|
/* Since we can't rely on _Static_assert always being available for
|
|
|
|
* all compilers we have limited static assert that can be used in
|
|
|
|
* C code but not in headers.
|
|
|
|
*/
|
|
|
|
#define _COGL_TYPEDEF_ASSERT(EXPRESSION) \
|
|
|
|
typedef struct { char Compile_Time_Assertion[(EXPRESSION) ? 1 : -1]; } \
|
|
|
|
G_PASTE (_GStaticAssert_, __LINE__)
|
|
|
|
|
|
|
|
/* _COGL_STATIC_ASSERT:
|
|
|
|
* @expression: An expression to assert evaluates to true at compile
|
|
|
|
* time.
|
|
|
|
* @message: A message to print to the console if the assertion fails
|
|
|
|
* at compile time.
|
|
|
|
*
|
|
|
|
* Allows you to assert that an expression evaluates to true at
|
|
|
|
* compile time and aborts compilation if not. If possible message
|
|
|
|
* will also be printed if the assertion fails.
|
|
|
|
*
|
|
|
|
* Note: Only Gcc >= 4.6 supports the c11 _Static_assert which lets us
|
|
|
|
* print a nice message if the compile time assertion fails.
|
|
|
|
*/
|
|
|
|
#ifdef HAVE_STATIC_ASSERT
|
|
|
|
#define _COGL_STATIC_ASSERT(EXPRESSION, MESSAGE) \
|
2013-10-14 16:28:11 +00:00
|
|
|
_Static_assert (EXPRESSION, MESSAGE);
|
2012-04-16 16:23:15 +00:00
|
|
|
#else
|
2013-10-14 16:28:11 +00:00
|
|
|
#define _COGL_STATIC_ASSERT(EXPRESSION, MESSAGE)
|
2012-04-16 16:23:15 +00:00
|
|
|
#endif
|
|
|
|
|
2012-08-07 10:45:29 +00:00
|
|
|
#ifdef HAVE_MEMMEM
|
|
|
|
#define _cogl_util_memmem memmem
|
|
|
|
#else
|
|
|
|
char *
|
|
|
|
_cogl_util_memmem (const void *haystack,
|
|
|
|
size_t haystack_len,
|
|
|
|
const void *needle,
|
|
|
|
size_t needle_len);
|
|
|
|
#endif
|
|
|
|
|
2012-10-02 10:44:00 +00:00
|
|
|
static inline void
|
|
|
|
_cogl_util_scissor_intersect (int rect_x0,
|
|
|
|
int rect_y0,
|
|
|
|
int rect_x1,
|
|
|
|
int rect_y1,
|
|
|
|
int *scissor_x0,
|
|
|
|
int *scissor_y0,
|
|
|
|
int *scissor_x1,
|
|
|
|
int *scissor_y1)
|
|
|
|
{
|
|
|
|
*scissor_x0 = MAX (*scissor_x0, rect_x0);
|
|
|
|
*scissor_y0 = MAX (*scissor_y0, rect_y0);
|
|
|
|
*scissor_x1 = MIN (*scissor_x1, rect_x1);
|
|
|
|
*scissor_y1 = MIN (*scissor_y1, rect_y1);
|
|
|
|
}
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
#endif /* __COGL_UTIL_H */
|