vecConst.h

Go to the documentation of this file.

/*
 * $Id: vecConst.h,v 1.4 2003/09/05 04:20:12 jmk Exp $
 */
///////////////////////////////////////////////////////////////////////////
//              _____________  ______________________    __   __  _____
//             /  ________  |  |   ___   ________   /   |  \ /  \   |
//            |  |       |  |_ |  |_ |  |       /  /    \__  |      |
//            |  |  ___  |  || |  || |  |      /  /        | |      |
//            |  | |   \ |  || |  || |  |     /  /      \__/ \__/ __|__
//            |  | |_@  ||  || |  || |  |    /  /          Institute
//            |  |___/  ||  ||_|  || |  |   /  /_____________________
//             \_______/  \______/ | |__|  /___________________________
//                        |  |__|  |
//                         \______/
//                    University of Utah       
//                           2002
///////////////////////////////////////////////////////////////////////////

//VecConst.h

#ifndef __VECTOR_CONST_H
#define __VECTOR_CONST_H

#include <../mathGutz/vec2.h>
#include <../mathGutz/vec3.h>
#include <../mathGutz/vec4.h>
#include <../mathGutz/quat.h>
#include <../mathGutz/mat2.h>
#include <../mathGutz/mat3.h>
#include <../mathGutz/mat4.h>

namespace gutz
{ 

//-----------------------------------------------------------------------------
// vec2 constants
//-----------------------------------------------------------------------------

//zero
const vec2f vec2f_zero = vec2f(0);
const vec2d vec2d_zero = vec2d(0);
const vec2i vec2i_zero = vec2i(0);

//one
const vec2f vec2f_one = vec2f(1);
const vec2d vec2d_one = vec2d(1);
const vec2i vec2i_one = vec2i(1);

//-one
const vec2f vec2f_neg_one = vec2f(-1);
const vec2d vec2d_neg_one = vec2d(-1);
const vec2i vec2i_neg_one = vec2i(-1);

// x
const vec2f vec2f_x = vec2f(1, 0);
const vec2d vec2d_x = vec2d(1, 0);
const vec2i vec2i_x = vec2i(1, 0);

// -x
const vec2f vec2f_neg_x = vec2f(-1, 0);
const vec2d vec2d_neg_x = vec2d(-1, 0);
const vec2i vec2i_neg_x = vec2i(-1, 0);

// y
const vec2f vec2f_y = vec2f(0, 1);
const vec2d vec2d_y = vec2d(0, 1);
const vec2i vec2i_y = vec2i(0, 1);

// -y
const vec2f vec2f_neg_y = vec2f(0, -1);
const vec2d vec2d_neg_y = vec2d(0, -1);
const vec2i vec2i_neg_y = vec2i(0, -1);

// xy
const vec2f vec2f_xy = vec2f(1, 1);
const vec2d vec2d_xy = vec2d(1, 1);
const vec2i vec2i_xy = vec2i(1, 1);

// -xy
const vec2f vec2f_neg_xy = vec2f(-1, -1);
const vec2d vec2d_neg_xy = vec2d(-1, -1);
const vec2i vec2i_neg_xy = vec2i(-1, -1);

//-----------------------------------------------------------------------------
// vec3 constants
//-----------------------------------------------------------------------------

//zero
const vec3f vec3f_zero = vec3f(0);
const vec3d vec3d_zero = vec3d(0);

//one
const vec3f vec3f_one = vec3f(1);
const vec3d vec3d_one = vec3d(1);

//-one
const vec3f vec3f_neg_one = vec3f(-1);
const vec3d vec3d_neg_one = vec3d(-1);

//.5
const vec3f vec3f_half = vec3f(.5);
const vec3d vec3d_half = vec3d(.5);

//-.5
const vec3f vec3f_neg_half = vec3f(-.5);
const vec3d vec3d_neg_half = vec3d(-.5);

//x axis
const vec3f vec3f_x = vec3f(1,0,0);
const vec3d vec3d_x = vec3d(1,0,0);
const vec3f vec3f_neg_x = vec3f(-1,0,0);
const vec3d vec3d_neg_x = vec3d(-1,0,0);

//y axis
const vec3f vec3f_y = vec3f(0,1,0);
const vec3d vec3d_y = vec3d(0,1,0);
const vec3f vec3f_neg_y = vec3f(0,-1,0);
const vec3d vec3d_neg_y = vec3d(0,-1,0);

//z axis
const vec3f vec3f_z = vec3f(0,0,1);
const vec3d vec3d_z = vec3d(0,0,1);
const vec3f vec3f_neg_z = vec3f(0,0,-1);
const vec3d vec3d_neg_z = vec3d(0,0,-1);

//xy axis
const vec3f vec3f_xy = vec3f(1,1,0);
const vec3d vec3d_xy = vec3d(1,1,0);
const vec3f vec3f_neg_xy = vec3f(-1,-1,0);
const vec3d vec3d_neg_xy = vec3d(-1,-1,0);

//xz axis
const vec3f vec3f_xz = vec3f(1,0,1);
const vec3d vec3d_xz = vec3d(1,0,1);
const vec3f vec3f_neg_xz = vec3f(-1,0,-1);
const vec3d vec3d_neg_xz = vec3d(-1,0,-1);

//yz axis
const vec3f vec3f_yz = vec3f(0,1,1);
const vec3d vec3d_yz = vec3d(0,1,1);
const vec3f vec3f_neg_yz = vec3f(0,-1,-1);
const vec3d vec3d_neg_yz = vec3d(0,-1,-1);

//xyz axis
const vec3f vec3f_xyz = vec3f(1,1,1);
const vec3d vec3d_xyz = vec3d(1,1,1);
const vec3f vec3f_neg_xyz = vec3f(-1,-1,-1);
const vec3d vec3d_neg_xyz = vec3d(-1,-1,-1);

//min max
const vec3f vec3f_min = vec3f(1e-8f, 1e-8f, 1e-8f);
const vec3d vec3d_min = vec3d(1e-16f, 1e-16f, 1e-16f);
const vec3f vec3f_max = vec3f(1e8f, 1e8f, 1e8f);
const vec3d vec3d_max = vec3d(1e16f, 1e16f, 1e16f);

//-----------------------------------------------------------------------------
// vec4 constants
//-----------------------------------------------------------------------------

//zero
const vec4f vec4f_zero = vec4f(0);
const vec4d vec4d_zero = vec4d(0);

//one
const vec4f vec4f_one = vec4f(1);
const vec4d vec4d_one = vec4d(1);

//x axis
const vec4f vec4f_x = vec4f(1,0,0,0);
const vec4d vec4d_x = vec4d(1,0,0,0);
const vec4f vec4f_neg_x = vec4f(-1,0,0,0);
const vec4d vec4d_neg_x = vec4d(-1,0,0,0);

//y axis
const vec4f vec4f_y = vec4f(0,1,0,0);
const vec4d vec4d_y = vec4d(0,1,0,0);
const vec4f vec4f_neg_y = vec4f(0,-1,0,0);
const vec4d vec4d_neg_y = vec4d(0,-1,0,0);

//z axis
const vec4f vec4f_z = vec4f(0,0,1,0);
const vec4d vec4d_z = vec4d(0,0,1,0);
const vec4f vec4f_neg_z = vec4f(0,0,-1,0);
const vec4d vec4d_neg_z = vec4d(0,0,-1,0);

//w axis
const vec4f vec4f_w = vec4f(0,0,0,1);
const vec4d vec4d_w = vec4d(0,0,0,1);
const vec4f vec4f_neg_w = vec4f(0,0,0,-1);
const vec4d vec4d_neg_w = vec4d(0,0,0,-1);

//-----------------------------------------------------------------------------
// quaternion constants
//-----------------------------------------------------------------------------

//identity
const quatf quatf_id = quatf();
const quatd quatd_id = quatd();

//-----------------------------------------------------------------------------
// mat2 constants
//-----------------------------------------------------------------------------

//identity
const mat2f mat2f_id = mat2f();
const mat2d mat2d_id = mat2d();

//zero
const mat2f mat2f_zero = mat2f(0.0f);
const mat2d mat2d_zero = mat2d(0.0);

//-----------------------------------------------------------------------------
// mat3 constants
//-----------------------------------------------------------------------------

//identity
const mat3f mat3f_id = mat3f();
const mat3d mat3d_id = mat3d();

//zero
const mat3f mat3f_zero = mat3f(0.0f);
const mat3d mat3d_zero = mat3d(0.0);

//-----------------------------------------------------------------------------
// mat4 constants
//-----------------------------------------------------------------------------

const mat4f mat4f_id = mat4f();
const mat4d mat4d_id = mat4d();

//zero
const mat4f mat4f_zero = mat4f(0.0f);
const mat4d mat4d_zero = mat4d(0.0);


}// end of namspace gutz


#endif

---

Send questions, comments, and bug reports to: