~ubuntu-branches/ubuntu/saucy/emscripten/saucy-proposed

1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

#ifndef _BOOLINVEC_H

#define _BOOLINVEC_H

#include <math.h>

namespace Vectormath {

class floatInVec;

//--------------------------------------------------------------------------------------------------

// boolInVec class

class boolInVec

{

private:

unsigned int mData;

public:

// Default constructor; does no initialization

inline boolInVec( ) { };

// Construct from a value converted from float

inline boolInVec(floatInVec vec);

// Explicit cast from bool

explicit inline boolInVec(bool scalar);

// Explicit cast to bool

inline bool getAsBool() const;

#ifndef _VECTORMATH_NO_SCALAR_CAST

// Implicit cast to bool

inline operator bool() const;

#endif

// Boolean negation operator

inline const boolInVec operator ! () const;

// Assignment operator

inline boolInVec& operator = (boolInVec vec);

// Boolean and assignment operator

inline boolInVec& operator &= (boolInVec vec);

// Boolean exclusive or assignment operator

inline boolInVec& operator ^= (boolInVec vec);

// Boolean or assignment operator

inline boolInVec& operator |= (boolInVec vec);

};

// Equal operator

inline const boolInVec operator == (boolInVec vec0, boolInVec vec1);

// Not equal operator

inline const boolInVec operator != (boolInVec vec0, boolInVec vec1);

// And operator

inline const boolInVec operator & (boolInVec vec0, boolInVec vec1);

// Exclusive or operator

inline const boolInVec operator ^ (boolInVec vec0, boolInVec vec1);

// Or operator

inline const boolInVec operator | (boolInVec vec0, boolInVec vec1);

// Conditionally select between two values

100

101

inline const boolInVec select(boolInVec vec0, boolInVec vec1, boolInVec select_vec1);

102

103

104

} // namespace Vectormath

105

106

107

//--------------------------------------------------------------------------------------------------

108

// boolInVec implementation

109

110

111

#include "floatInVec.h"

112

113

namespace Vectormath {

114

115

inline

116

boolInVec::boolInVec(floatInVec vec)

117

{

118

*this = (vec != floatInVec(0.0f));

119

}

120

121

inline

122

boolInVec::boolInVec(bool scalar)

123

{

124

mData = -(int)scalar;

125

}

126

127

inline

128

bool

129

boolInVec::getAsBool() const

130

{

131

return (mData > 0);

132

}

133

134

#ifndef _VECTORMATH_NO_SCALAR_CAST

135

inline

136

boolInVec::operator bool() const

137

{

138

return getAsBool();

139

}

140

#endif

141

142

inline

143

const boolInVec

144

boolInVec::operator ! () const

145

{

146

return boolInVec(!mData);

147

}

148

149

inline

150

boolInVec&

151

boolInVec::operator = (boolInVec vec)

152

{

153

mData = vec.mData;

154

return *this;

155

}

156

157

inline

158

boolInVec&

159

boolInVec::operator &= (boolInVec vec)

160

{

161

*this = *this & vec;

162

return *this;

163

}

164

165

inline

166

boolInVec&

167

boolInVec::operator ^= (boolInVec vec)

168

{

169

*this = *this ^ vec;

170

return *this;

171

}

172

173

inline

174

boolInVec&

175

boolInVec::operator |= (boolInVec vec)

176

{

177

*this = *this | vec;

178

return *this;

179

}

180

181

inline

182

const boolInVec

183

operator == (boolInVec vec0, boolInVec vec1)

184

{

185

return boolInVec(vec0.getAsBool() == vec1.getAsBool());

186

}

187

188

inline

189

const boolInVec

190

operator != (boolInVec vec0, boolInVec vec1)

191

{

192

return !(vec0 == vec1);

193

}

194

195

inline

196

const boolInVec

197

operator & (boolInVec vec0, boolInVec vec1)

198

{

199

return boolInVec(vec0.getAsBool() & vec1.getAsBool());

200

}

201

202

inline

203

const boolInVec

204

operator | (boolInVec vec0, boolInVec vec1)

205

{

206

return boolInVec(vec0.getAsBool() | vec1.getAsBool());

207

}

208

209

inline

210

const boolInVec

211

operator ^ (boolInVec vec0, boolInVec vec1)

212

{

213

return boolInVec(vec0.getAsBool() ^ vec1.getAsBool());

214

}

215

216

inline

217

const boolInVec

218

select(boolInVec vec0, boolInVec vec1, boolInVec select_vec1)

219

{

220

return (select_vec1.getAsBool() == 0) ? vec0 : vec1;

221

}

222

223

} // namespace Vectormath

224

225

#endif // boolInVec_h

Older »