WebSVN – gelsvn – Diff – /trunk/src/CGLA/BitMask.h


#ifndef __CGLA__BITMASK_H__
#define __CGLA__BITMASK_H__
 
#include "Vec3i.h"
 
namespace CGLA
{
	const int MASKS[33] = 
		{
			0x00000000,
			0x00000001,
			0x00000003,
			0x00000007,
			0x0000000f,
			0x0000001f,
			0x0000003f,
			0x0000007f,
			0x000000ff,
			0x000001ff,
			0x000003ff,
			0x000007ff,
			0x00000fff,
			0x00001fff,
			0x00003fff,
			0x00007fff,
			0x0000ffff,
			0x0001ffff,
			0x0003ffff,
			0x0007ffff,
			0x000fffff,
			0x001fffff,
			0x003fffff,
			0x007fffff,
			0x00ffffff,
			0x01ffffff,
			0x03ffffff,
			0x07ffffff,
			0x0fffffff,
			0x1fffffff,
			0x3fffffff,
			0x7fffffff,
			0xffffffff
		};
 
	/** \brief The BitMask class is mostly a utility class.
 
			The main purpose is to be able to extract a set of bits from
			an integer. For instance this can be useful if we traverse
			some tree structure and the integer is the index. */
	class BitMask
	{
		int fb, lb, bdiff;
		int msk;
 
	public:
 
		/** Mask _fb-_lb+1 bits beginning from _fb. First bit is 0.
				Say _fb=_lb=0. In this case, mask 1 bit namely 0.*/
		BitMask(int _fb, int _lb):
			fb(_fb), lb(_lb), 
			bdiff(lb-fb+1), msk(MASKS[bdiff]<<fb)
		{}
	
		/// first bit is 0 mask num bits.
		BitMask(int num):
			fb(0),lb(two_to_what_power(num)-1), 
			bdiff(lb-fb+1), msk(MASKS[bdiff]<<fb)
		{}
	
		/// Mask everything.
		BitMask():
			fb(0), lb(15),
			bdiff(lb-fb+1), msk(MASKS[bdiff]<<fb)
		{}
 
		/// get number of first bit in mask
		int first_bit() const {return fb;} 
 
		/// get number of last bit in mask
 		int last_bit() const {return lb;}
 
		/// Return number of masked bits
		int no_bits() const {return bdiff;}
 
		/// Mask a number
		int mask(int var) const {return msk&var;}
		
		/** Mask a number and shift back so the first bit inside
				the mask becomes bit 0. */
		int mask_shift(int var) const {return (msk&var)>>fb;}
 
		/** Mask a vector by masking each coordinate. */
		Vec3i mask(const Vec3i& v) const 
		{
			return Vec3i(mask(v[0]),mask(v[1]),mask(v[2]));
		}
  
		/** Mask each coord of a vector and shift */
		Vec3i maskshift(const Vec3i& v) const 
		{
			return Vec3i(mask_shift(v[0]),mask_shift(v[1]),mask_shift(v[2]));
		}
  
	};
 
}
#endif
 

Rev 2	Rev 89
1	`#ifndef __CGLA__BITMASK_H__`	1	`#ifndef __CGLA__BITMASK_H__`
2	`#define __CGLA__BITMASK_H__`	2	`#define __CGLA__BITMASK_H__`
3		3
4	`#include "Vec3i.h"`	4	`#include "Vec3i.h"`
5		5
6	`namespace CGLA`	6	`namespace CGLA`
7	`{`	7	`{`
8	`const int MASKS[33] =`	8	`const int MASKS[33] =`
9	`{`	9	`{`
10	`0x00000000,`	10	`0x00000000,`
11	`0x00000001,`	11	`0x00000001,`
12	`0x00000003,`	12	`0x00000003,`
13	`0x00000007,`	13	`0x00000007,`
14	`0x0000000f,`	14	`0x0000000f,`
15	`0x0000001f,`	15	`0x0000001f,`
16	`0x0000003f,`	16	`0x0000003f,`
17	`0x0000007f,`	17	`0x0000007f,`
18	`0x000000ff,`	18	`0x000000ff,`
19	`0x000001ff,`	19	`0x000001ff,`
20	`0x000003ff,`	20	`0x000003ff,`
21	`0x000007ff,`	21	`0x000007ff,`
22	`0x00000fff,`	22	`0x00000fff,`
23	`0x00001fff,`	23	`0x00001fff,`
24	`0x00003fff,`	24	`0x00003fff,`
25	`0x00007fff,`	25	`0x00007fff,`
26	`0x0000ffff,`	26	`0x0000ffff,`
27	`0x0001ffff,`	27	`0x0001ffff,`
28	`0x0003ffff,`	28	`0x0003ffff,`
29	`0x0007ffff,`	29	`0x0007ffff,`
30	`0x000fffff,`	30	`0x000fffff,`
31	`0x001fffff,`	31	`0x001fffff,`
32	`0x003fffff,`	32	`0x003fffff,`
33	`0x007fffff,`	33	`0x007fffff,`
34	`0x00ffffff,`	34	`0x00ffffff,`
35	`0x01ffffff,`	35	`0x01ffffff,`
36	`0x03ffffff,`	36	`0x03ffffff,`
37	`0x07ffffff,`	37	`0x07ffffff,`
38	`0x0fffffff,`	38	`0x0fffffff,`
39	`0x1fffffff,`	39	`0x1fffffff,`
40	`0x3fffffff,`	40	`0x3fffffff,`
41	`0x7fffffff,`	41	`0x7fffffff,`
42	`0xffffffff`	42	`0xffffffff`
43	`};`	43	`};`
44		44
45	`/** The BitMask class is mostly a utility class.`	45	`/** \brief The BitMask class is mostly a utility class.`
-		46
46	`The main purpose is to be able to extract a set of bits from`	47	`The main purpose is to be able to extract a set of bits from`
47	`an integer. For instance this can be useful if we traverse`	48	`an integer. For instance this can be useful if we traverse`
48	`some tree structure and the integer is the index. */`	49	`some tree structure and the integer is the index. */`
49	`class BitMask`	50	`class BitMask`
50	`{`	51	`{`
51	`int fb, lb, bdiff;`	52	`int fb, lb, bdiff;`
52	`int msk;`	53	`int msk;`
53		54
54	`public:`	55	`public:`
55		56
56	`/** Mask _fb-_lb+1 bits beginning from _fb. First bit is 0.`	57	`/** Mask _fb-_lb+1 bits beginning from _fb. First bit is 0.`
57	`Say _fb=_lb=0. In this case, mask 1 bit namely 0.*/`	58	`Say _fb=_lb=0. In this case, mask 1 bit namely 0.*/`
58	`BitMask(int _fb, int _lb):`	59	`BitMask(int _fb, int _lb):`
59	`fb(_fb), lb(_lb),`	60	`fb(_fb), lb(_lb),`
60	`bdiff(lb-fb+1), msk(MASKS[bdiff]<<fb)`	61	`bdiff(lb-fb+1), msk(MASKS[bdiff]<<fb)`
61	`{}`	62	`{}`
62		63
63	`/// first bit is 0 mask num bits.`	64	`/// first bit is 0 mask num bits.`
64	`BitMask(int num):`	65	`BitMask(int num):`
65	`fb(0),lb(two_to_what_power(num)-1),`	66	`fb(0),lb(two_to_what_power(num)-1),`
66	`bdiff(lb-fb+1), msk(MASKS[bdiff]<<fb)`	67	`bdiff(lb-fb+1), msk(MASKS[bdiff]<<fb)`
67	`{}`	68	`{}`
68		69
69	`/// Mask everything.`	70	`/// Mask everything.`
70	`BitMask():`	71	`BitMask():`
71	`fb(0), lb(15),`	72	`fb(0), lb(15),`
72	`bdiff(lb-fb+1), msk(MASKS[bdiff]<<fb)`	73	`bdiff(lb-fb+1), msk(MASKS[bdiff]<<fb)`
73	`{}`	74	`{}`
74		75
75	`/// get number of first bit in mask`	76	`/// get number of first bit in mask`
76	`int first_bit() const {return fb;}`	77	`int first_bit() const {return fb;}`
77		78
78	`/// get number of last bit in mask`	79	`/// get number of last bit in mask`
79	`int last_bit() const {return lb;}`	80	`int last_bit() const {return lb;}`
80		81
81	`/// Return number of masked bits`	82	`/// Return number of masked bits`
82	`int no_bits() const {return bdiff;}`	83	`int no_bits() const {return bdiff;}`
83		84
84	`/// Mask a number`	85	`/// Mask a number`
85	`int mask(int var) const {return msk&var;}`	86	`int mask(int var) const {return msk&var;}`
86		87
87	`/** Mask a number and shift back so the first bit inside`	88	`/** Mask a number and shift back so the first bit inside`
88	`the mask becomes bit 0. */`	89	`the mask becomes bit 0. */`
89	`int mask_shift(int var) const {return (msk&var)>>fb;}`	90	`int mask_shift(int var) const {return (msk&var)>>fb;}`
90		91
91	`/** Mask a vector by masking each coordinate. */`	92	`/** Mask a vector by masking each coordinate. */`
92	`Vec3i mask(const Vec3i& v) const`	93	`Vec3i mask(const Vec3i& v) const`
93	`{`	94	`{`
94	`return Vec3i(mask(v[0]),mask(v[1]),mask(v[2]));`	95	`return Vec3i(mask(v[0]),mask(v[1]),mask(v[2]));`
95	`}`	96	`}`
96		97
97	`/** Mask each coord of a vector and shift */`	98	`/** Mask each coord of a vector and shift */`
98	`Vec3i maskshift(const Vec3i& v) const`	99	`Vec3i maskshift(const Vec3i& v) const`
99	`{`	100	`{`
100	`return Vec3i(mask_shift(v[0]),mask_shift(v[1]),mask_shift(v[2]));`	101	`return Vec3i(mask_shift(v[0]),mask_shift(v[1]),mask_shift(v[2]));`
101	`}`	102	`}`
102		103
103	`};`	104	`};`
104		105
105	`}`	106	`}`
106	`#endif`	107	`#endif`
107		108

Subversion Repositories gelsvn

(root)/trunk/src/CGLA/BitMask.h – Rev 2 → 89