isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-09-20 06:25:51 -04:00
Code Issues Packages Projects Releases Wiki Activity
f4c1ba9ed9
mutter/cogl/cogl-bitmask.c

275 lines
7.5 KiB
C
Raw Normal View History

cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2010 Intel Corporation.
*
* 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
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
*
* Authors:
* Neil Roberts <neil@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <glib.h>
#include <string.h>
#include "cogl-bitmask.h"
cogl-bitmask: Use ffsl to speedup bitmask iteration Instead of testing each bit when iterating a bitmask, we can use ffsl to skip over unset bits in single instruction. That way it will scale by the number of bits set, not the total number of bits. ffsl is a non-standard function which glibc only provides by defining GNUC_SOURCE. However if we are compiling with GCC we can avoid that mess and just use the equivalent builtin. When not compiling for GCC it will fall back to _cogl_util_ffs if the size of ints and longs are the same (which is the case on i686). Otherwise it fallbacks to a slow function implementation. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 15:09:53 -04:00
#include "cogl-util.h"
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
/* This code assumes that we can cast an unsigned long to a pointer
and back without losing any data */
G_STATIC_ASSERT (sizeof (unsigned long) <= sizeof (void *));
#define ARRAY_INDEX(bit_num) \
((bit_num) / (sizeof (unsigned long) * 8))
#define BIT_INDEX(bit_num) \
((bit_num) & (sizeof (unsigned long) * 8 - 1))
#define BIT_MASK(bit_num) \
(1UL << BIT_INDEX (bit_num))
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
gboolean
_cogl_bitmask_get_from_array (const CoglBitmask *bitmask,
unsigned int bit_num)
{
GArray *array = (GArray *) *bitmask;
/* If the index is off the end of the array then assume the bit is
not set */
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
if (bit_num >= sizeof (unsigned long) * 8 * array->len)
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
return FALSE;
else
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
return !!(g_array_index (array, unsigned long, ARRAY_INDEX (bit_num)) &
BIT_MASK (bit_num));
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
static void
_cogl_bitmask_convert_to_array (CoglBitmask *bitmask)
{
GArray *array;
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
/* Fetch the old values */
unsigned long old_values = _cogl_bitmask_to_bits (bitmask);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
array = g_array_new (FALSE, /* not zero-terminated */
TRUE, /* do clear new entries */
sizeof (unsigned long));
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
/* Copy the old values back in */
g_array_append_val (array, old_values);
*bitmask = (struct _CoglBitmaskImaginaryType *) array;
}
void
_cogl_bitmask_set_in_array (CoglBitmask *bitmask,
unsigned int bit_num,
gboolean value)
{
GArray *array;
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
unsigned int array_index;
unsigned long new_value_mask;
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
/* If the bitmask is not already an array then we need to allocate one */
if (!_cogl_bitmask_has_array (bitmask))
_cogl_bitmask_convert_to_array (bitmask);
array = (GArray *) *bitmask;
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
array_index = ARRAY_INDEX (bit_num);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
/* Grow the array if necessary. This will clear the new data */
if (array_index >= array->len)
g_array_set_size (array, array_index + 1);
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
new_value_mask = BIT_MASK (bit_num);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
if (value)
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
g_array_index (array, unsigned long, array_index) |= new_value_mask;
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
else
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
g_array_index (array, unsigned long, array_index) &= ~new_value_mask;
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
void
_cogl_bitmask_set_bits (CoglBitmask *dst,
const CoglBitmask *src)
{
if (_cogl_bitmask_has_array (src))
{
GArray *src_array, *dst_array;
int i;
if (!_cogl_bitmask_has_array (dst))
_cogl_bitmask_convert_to_array (dst);
dst_array = (GArray *) *dst;
src_array = (GArray *) *src;
if (dst_array->len < src_array->len)
g_array_set_size (dst_array, src_array->len);
for (i = 0; i < src_array->len; i++)
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
g_array_index (dst_array, unsigned long, i) |=
g_array_index (src_array, unsigned long, i);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
else if (_cogl_bitmask_has_array (dst))
{
GArray *dst_array;
dst_array = (GArray *) *dst;
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
g_array_index (dst_array, unsigned long, 0) |=
_cogl_bitmask_to_bits (src);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
else
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
*dst = _cogl_bitmask_from_bits (_cogl_bitmask_to_bits (dst) |
_cogl_bitmask_to_bits (src));
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
void
_cogl_bitmask_set_range_in_array (CoglBitmask *bitmask,
unsigned int n_bits,
gboolean value)
{
GArray *array;
unsigned int array_index, bit_index;
if (n_bits == 0)
return;
/* If the bitmask is not already an array then we need to allocate one */
if (!_cogl_bitmask_has_array (bitmask))
_cogl_bitmask_convert_to_array (bitmask);
array = (GArray *) *bitmask;
/* Get the array index of the top most value that will be touched */
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
array_index = ARRAY_INDEX (n_bits - 1);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
/* Get the bit index of the top most value */
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
bit_index = BIT_INDEX (n_bits - 1);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
/* Grow the array if necessary. This will clear the new data */
if (array_index >= array->len)
g_array_set_size (array, array_index + 1);
if (value)
{
/* Set the bits that are touching this index */
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
g_array_index (array, unsigned long, array_index) |=
~0UL >> (sizeof (unsigned long) * 8 - 1 - bit_index);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
/* Set all of the bits in any lesser indices */
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
memset (array->data, 0xff, sizeof (unsigned long) * array_index);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
else
{
/* Clear the bits that are touching this index */
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
g_array_index (array, unsigned long, array_index) &= ~1UL << bit_index;
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
/* Clear all of the bits in any lesser indices */
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
memset (array->data, 0x00, sizeof (unsigned long) * array_index);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
}
void
cogl-vertex-attribute: Use glVertexAttribPointer on GLES2 When the GLES2 wrapper is removed we can't use the fixed function API such as glColorPointer to set the builtin attributes. Instead the GLSL progend now maintains a cache of attribute locations that are queried with glGetAttribLocation. The code that previously maintained a cache of the enabled texture coord arrays has been modified to also cache the enabled vertex attributes under GLES2. The vertex attribute API is now the only place that is using this cache so it has been moved into cogl-vertex-attribute.c
2010-12-03 12:46:16 -05:00
_cogl_bitmask_xor_bits (CoglBitmask *dst,
const CoglBitmask *src)
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
{
if (_cogl_bitmask_has_array (src))
{
GArray *src_array, *dst_array;
int i;
if (!_cogl_bitmask_has_array (dst))
_cogl_bitmask_convert_to_array (dst);
dst_array = (GArray *) *dst;
src_array = (GArray *) *src;
if (dst_array->len < src_array->len)
g_array_set_size (dst_array, src_array->len);
for (i = 0; i < src_array->len; i++)
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
g_array_index (dst_array, unsigned long, i) ^=
g_array_index (src_array, unsigned long, i);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
else if (_cogl_bitmask_has_array (dst))
{
GArray *dst_array;
dst_array = (GArray *) *dst;
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
g_array_index (dst_array, unsigned long, 0) ^=
_cogl_bitmask_to_bits (src);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
else
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
*dst = _cogl_bitmask_from_bits (_cogl_bitmask_to_bits (dst) ^
_cogl_bitmask_to_bits (src));
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
void
_cogl_bitmask_clear_all_in_array (CoglBitmask *bitmask)
{
GArray *array = (GArray *) *bitmask;
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
memset (array->data, 0, sizeof (unsigned long) * array->len);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
void
_cogl_bitmask_foreach (const CoglBitmask *bitmask,
CoglBitmaskForeachFunc func,
gpointer user_data)
{
if (_cogl_bitmask_has_array (bitmask))
{
GArray *array = (GArray *) *bitmask;
int array_index;
for (array_index = 0; array_index < array->len; array_index++)
{
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
unsigned long mask =
g_array_index (array, unsigned long, array_index);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
int bit = 0;
while (mask)
{
cogl-bitmask: Use ffsl to speedup bitmask iteration Instead of testing each bit when iterating a bitmask, we can use ffsl to skip over unset bits in single instruction. That way it will scale by the number of bits set, not the total number of bits. ffsl is a non-standard function which glibc only provides by defining GNUC_SOURCE. However if we are compiling with GCC we can avoid that mess and just use the equivalent builtin. When not compiling for GCC it will fall back to _cogl_util_ffs if the size of ints and longs are the same (which is the case on i686). Otherwise it fallbacks to a slow function implementation. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 15:09:53 -04:00
int next_bit = _cogl_util_ffsl (mask);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
cogl-bitmask: Use ffsl to speedup bitmask iteration Instead of testing each bit when iterating a bitmask, we can use ffsl to skip over unset bits in single instruction. That way it will scale by the number of bits set, not the total number of bits. ffsl is a non-standard function which glibc only provides by defining GNUC_SOURCE. However if we are compiling with GCC we can avoid that mess and just use the equivalent builtin. When not compiling for GCC it will fall back to _cogl_util_ffs if the size of ints and longs are the same (which is the case on i686). Otherwise it fallbacks to a slow function implementation. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 15:09:53 -04:00
bit += next_bit;
mask >>= next_bit;
func (array_index * sizeof (unsigned long) * 8 + bit - 1,
user_data);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
}
}
else
{
cogl-bitmask: Use longs instead of ints Instead of storing only 31 bits in the pointer for a CoglBitmask, it now assumes it can store a whole unsigned long minus the one bit used to mark whether it has been converted to a GArray or not. This works on the assumption that we can cast an unsigned long to a pointer and back without losing information which I think should be true for any platforms that Cogl is interested in. This has the advantage that on 64-bit architectures we can store 63 bits before we have to resort to using a GArray at no extra cost. The values in the GArray are now stored as unsigned longs as well on the assumption that it is more efficient to load and store data in chunks of longs rather than ints. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 09:58:02 -04:00
unsigned long mask = _cogl_bitmask_to_bits (bitmask);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
int bit = 0;
while (mask)
{
cogl-bitmask: Use ffsl to speedup bitmask iteration Instead of testing each bit when iterating a bitmask, we can use ffsl to skip over unset bits in single instruction. That way it will scale by the number of bits set, not the total number of bits. ffsl is a non-standard function which glibc only provides by defining GNUC_SOURCE. However if we are compiling with GCC we can avoid that mess and just use the equivalent builtin. When not compiling for GCC it will fall back to _cogl_util_ffs if the size of ints and longs are the same (which is the case on i686). Otherwise it fallbacks to a slow function implementation. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 15:09:53 -04:00
int next_bit = _cogl_util_ffsl (mask);
bit += next_bit;
mask >>= next_bit;
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
cogl-bitmask: Use ffsl to speedup bitmask iteration Instead of testing each bit when iterating a bitmask, we can use ffsl to skip over unset bits in single instruction. That way it will scale by the number of bits set, not the total number of bits. ffsl is a non-standard function which glibc only provides by defining GNUC_SOURCE. However if we are compiling with GCC we can avoid that mess and just use the equivalent builtin. When not compiling for GCC it will fall back to _cogl_util_ffs if the size of ints and longs are the same (which is the case on i686). Otherwise it fallbacks to a slow function implementation. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 15:09:53 -04:00
func (bit - 1, user_data);
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 12:31:42 -04:00
}
}
}
Reference in New Issue Copy Permalink