ivu_linear.hxx

hl2 source code. Do not use it illegal.

     *	Description:	returns the degree of freedom of the eigenvector
     ********************************************************************************/
    int calc_eigen_vector(IVP_DOUBLE eigen_value, IVP_U_Point *eigen_vector_out);
    
    void init_columns3(const IVP_U_Point *v0, const IVP_U_Point *v1, const IVP_U_Point *v2);    // sets this columns to v0,v1,v2, 
    void init_rows3(const IVP_U_Point *v0, const IVP_U_Point *v1, const IVP_U_Point *v2);	// sets this rows    to v0,v1,v2

    
    /********************************************************************************
     *	Name:	       	init_normized3
     *	Description:	creates a normized matrix
     *			the user can predefine one given row/col
     ********************************************************************************/
    void init_normized3_col(const IVP_U_Point *v, IVP_COORDINATE_INDEX coordinate_index);      // init orthornomized matrix given any axis
    void init_normized3_col(const IVP_U_Point *vb, IVP_COORDINATE_INDEX coordinate_index, const IVP_U_Point *vc);      // init orthornomized matrix given any two axes
    void init_normized3_row(const IVP_U_Point *v, IVP_COORDINATE_INDEX coordinate_index);      // init orthornomized matrix given any axis
    void init_normized3_row(const IVP_U_Point *vb, IVP_COORDINATE_INDEX coordinate_index, const IVP_U_Point *vc);      // init orthornomized matrix given any two axes

    void init_rotated3(IVP_COORDINATE_INDEX axis, IVP_FLOAT angle);  // init this matrix as a rotation around the given axis
    
    inline void get_row(IVP_COORDINATE_INDEX row, IVP_U_Point *row_out) const;
    inline void get_row(IVP_COORDINATE_INDEX row, IVP_U_Float_Point *row_out) const;
    inline void get_col(IVP_COORDINATE_INDEX column, IVP_U_Point *col_out) const;
    inline void get_col(IVP_COORDINATE_INDEX column, IVP_U_Float_Point *col_out) const;

    inline void set_row(IVP_COORDINATE_INDEX row, const IVP_U_Point *);
    inline void set_row(IVP_COORDINATE_INDEX row, const IVP_U_Float_Point *);
    inline void set_col(IVP_COORDINATE_INDEX column, const IVP_U_Point *);
    inline void set_col(IVP_COORDINATE_INDEX column, const IVP_U_Float_Point *);

    IVP_DOUBLE get_determinante() const;
    IVP_RETURN_TYPE real_invert(IVP_DOUBLE epsilon = P_DOUBLE_EPS); 			// Using determinant algorithm

    void set_transpose3(const IVP_U_Matrix3 *m);
    void transpose3();
    void init3();	// sets this to the 'I' matrix

    // INTERN_START
    IVP_RETURN_TYPE get_angles(IVP_FLOAT *alpha, IVP_FLOAT *beta, IVP_FLOAT *gamma);  	// get the euler angles (real slow implementation)
    // INTERN_END

	void byte_swap() { rows[0].byte_swap(); rows[1].byte_swap(); rows[2].byte_swap(); }

};

/********************************************************************************
 *	Name:	       	IVP_U_Matrix
 *	Description:	3D transformation matrix: rotation (mm) and shift (vv)
 ********************************************************************************/
class IVP_U_Matrix: public IVP_U_Matrix3
{
public:    
    IVP_U_Point vv;	// Translations Vector, is added in vmult after rotation.

    IVP_U_Point *get_position() { return &vv; };				// get the position of an object matrix
    const IVP_U_Point *get_position() const { return &vv; };				// get the position of an object matrix

    inline void inline_mmult4(const IVP_U_Matrix *mb, IVP_U_Matrix *m_out ) const; // matrix multiplication
    inline void inline_mimult4(const IVP_U_Matrix *mb, IVP_U_Matrix *m_out ) const; // this is transposed !!
    void mmult4(const IVP_U_Matrix *mb, IVP_U_Matrix *m_out ) const;	//m_out = this*mb
    void mimult4(const IVP_U_Matrix *mb, IVP_U_Matrix *m_out ) const; 	//m_out = (this^-1) * mb
    
    void mi2mult4(const IVP_U_Matrix *mb, IVP_U_Matrix *m_out )const; //m_out = this * (mb^-1)
    void rotate(IVP_COORDINATE_INDEX axis, IVP_FLOAT angle, IVP_U_Matrix *m_out);  // m_out = this * I.init_rotated()
    void rotate_invers(IVP_COORDINATE_INDEX axis, IVP_FLOAT angle, IVP_U_Matrix *m_out);
    
#if !defined(IVP_NO_DOUBLE)
    inline void inline_vmult4 ( const IVP_U_Point *p_in, IVP_U_Point * p_out) const;	// p_out = this * p_in
    inline void inline_vmult4 ( const IVP_U_Float_Point *p_in, IVP_U_Point * p_out) const;	// p_out = this * p_in
    void vmult4 ( const IVP_U_Point *p_in, IVP_U_Point * p_out) const;			// p_out = this * p_in
    void vmult4 ( const IVP_U_Float_Point *p_in, IVP_U_Point * p_out) const;			// p_out = this * p_in
#endif
    inline void inline_vmult4 ( const IVP_U_Float_Point *p_in, IVP_U_Float_Point * p_out) const;	// p_out = this * p_in (e.g. object space to core space)
    void vmult4 ( const IVP_U_Float_Point *p_in, IVP_U_Float_Point * p_out) const;			// p_out = this * p_in


#if !defined(IVP_NO_DOUBLE)
    inline void inline_vimult4( const IVP_U_Point *p_in, IVP_U_Point * p_out ) const;			// p_out = (this^-1) * p_in
    inline void inline_vimult4( const IVP_U_Point *p_in, IVP_U_Float_Point * p_out ) const;	// p_out = (this^-1) * p_in
    void vimult4( const IVP_U_Point *p_in, IVP_U_Float_Point * p_out ) const;			// p_out = (this^-1) * p_in			   
    void vimult4( const IVP_U_Point *p_in, IVP_U_Point * p_out ) const;			// p_out = (this^-1) * p_in			   
#endif
    inline void inline_vimult4( const IVP_U_Float_Point *p_in, IVP_U_Float_Point * p_out ) const;	// p_out = (this^-1) * p_in    
    void vimult4( const IVP_U_Float_Point *p_in, IVP_U_Float_Point * p_out ) const;			// p_out = (this^-1) * p_in			   

    void transpose();
    void set_transpose(const IVP_U_Matrix *in);
	inline void get_4x4_column_major( IVP_FLOAT *out ) const;

    IVP_RETURN_TYPE real_invert(IVP_DOUBLE epsilon = P_DOUBLE_EPS); 			// Using determinant algorithm
    IVP_RETURN_TYPE real_invert(const IVP_U_Matrix *m, IVP_DOUBLE epsilon = P_DOUBLE_EPS); // Overload

    // INTERN_START
         /*************************************************************
          * Shifts an object matrix in world space.
          *************************************************************/
    void shift_ws( const IVP_U_Point *v_in );
    
         /*************************************************************
          * Shifts an object matrix in it's object space.
          *************************************************************/
    void shift_os( const IVP_U_Point *v_in );
    //INTERN_END
  
    
    void init();	// sets this to 'I'

    void init_rot_multiple(const  IVP_U_Point *angles, IVP_DOUBLE factor = 1.0f);	// sets this rotated (using euler angles) and position to 0,0,0

    void init_columns4(const IVP_U_Point *v0, const IVP_U_Point *v1, const IVP_U_Point *v2,const IVP_U_Point *shift);
    void init_rows4(const IVP_U_Point *v0, const IVP_U_Point *v1, const IVP_U_Point *v2,const IVP_U_Point *shift);
    void interpolate(const IVP_U_Matrix *m1, const IVP_U_Matrix *m2,    IVP_DOUBLE i_factor);                // this = m1 * (1.0f-factor) + m2 * factor

    IVP_DOUBLE quad_distance_to(const IVP_U_Matrix *m2);
    
    void set_matrix(const IVP_U_Matrix *mat) { *this=*mat; }
    
    void print(const char *headline = 0);
    IVP_ERROR_STRING write_to_file(FILE *fp,const char *key = 0);
    IVP_ERROR_STRING read_from_file(FILE *fp);

	void byte_swap() { vv.byte_swap(); IVP_U_Matrix3::byte_swap(); }
};



/********************************************************************************
 *	Name:	       	IVP_U_Quat
 *	Description:	Efficient treatment of rotation matrizes.	
 ********************************************************************************/
class IVP_U_Quat {
public:
    IVP_DOUBLE x,y,z,w;
    
    void set(IVP_DOUBLE rot_x, IVP_DOUBLE rot_y, IVP_DOUBLE rot_z);  // set rotation, Note: rot_ < IVP_PI_2
    void set_fast_multiple(const  IVP_U_Point *angles, IVP_DOUBLE factor); // sets x = sin( angles.k[0] * factor * 0.5f), y = ..   , w= 1 - sqrt(xx+yy+zz), lets the engine crash for angles > PI
    void set_fast_multiple_with_clip(const  IVP_U_Float_Point *angles, IVP_DOUBLE factor); // same as set_fast_multiple, but do not crash
    void set_very_fast_multiple(const  IVP_U_Float_Point *angles, IVP_DOUBLE factor);
    inline void init();
  void set_matrix(IVP_U_Matrix3 *mat3_out)const ;
    void set_matrix(IVP_DOUBLE m_out[4][4])const;
    void set_quaternion(const IVP_U_Matrix3 *mat3_in);
    void set_quaternion(const IVP_DOUBLE m_in[4][4]);
    void set_interpolate_smoothly(const IVP_U_Quat * from,const IVP_U_Quat * to, IVP_DOUBLE t);
    void set_interpolate_linear(const IVP_U_Quat * from,const  IVP_U_Quat * to, IVP_DOUBLE t);
    void normize_quat();
    void fast_normize_quat();           // works only on quads with |quad| = 1.0f +- 0.1f; very fast if quat is already nearly normized
  inline void normize_correct_step(int steps);        // increase precission of normized quad
    void invert_quat();
    void get_angles(IVP_U_Float_Point *angles_out);
    void set_from_rotation_vectors(IVP_DOUBLE x1,IVP_DOUBLE y1, IVP_DOUBLE z1, IVP_DOUBLE x2, IVP_DOUBLE y2, IVP_DOUBLE z2);
    inline void inline_set_mult_quat(const IVP_U_Quat* q1, const IVP_U_Quat* q2);
    inline void inline_set_mult_quat(const IVP_U_Quat* q1, const IVP_U_Float_Quat* q2);
    void set_mult_quat(const IVP_U_Quat* q1, const IVP_U_Quat* q2);
    inline IVP_DOUBLE acos_quat(const IVP_U_Quat* q1) const; // acosinus between two quats
    void set_div_unit_quat(const IVP_U_Quat* q1, const IVP_U_Quat* q2); // res = q1/q2; set div, if both quats are unit quats
    void set_invert_mult(const IVP_U_Quat* q1,const  IVP_U_Quat* q2); // res = 1.0f/q1 * q2
    void set_invert_unit_quat(const IVP_U_Quat *q1);  // invert unit quaternion

    inline IVP_DOUBLE inline_estimate_q_diff_to(const IVP_U_Float_Quat *reference) const;	// roughly estimate the quad alpha

    IVP_U_Quat(){};  // not initialized quat
    IVP_U_Quat(const IVP_U_Point &p){ this->set_fast_multiple(&p,1.0f); }; // init by a rotation
    IVP_U_Quat( const IVP_U_Matrix3 *m) { this->set_quaternion(m); }
    // INTERN_START
    //log_difference ?nicht kapiert
    //euler_to_quat
    //get_axis_and_angle
    //set_from_axis_and_angle
    //scale
    //Sqare
    //Sqrt
    //dot_product
    //length
    //negate
    //exponent
    //log
    // INTERN_END

	inline void byte_swap() { 
	#if defined(IVP_NO_DOUBLE)
		ivp_byte_swap4( (uint&) x);
		ivp_byte_swap4( (uint&) y);
		ivp_byte_swap4( (uint&) z);
		ivp_byte_swap4( (uint&) w);
	#else
		IVP_ASSERT( 0 && "No byte swap for double yet");
	#endif
	}


} IVP_ALIGN_16;



#if defined(IVP_NO_DOUBLE)
class IVP_U_Float_Quat: public IVP_U_Quat {
    public:	

#else

class IVP_U_Float_Quat {
public:
    IVP_FLOAT x,y,z,w;
#endif
    inline void set(const IVP_U_Quat *source);

	inline void byte_swap() { 
		ivp_byte_swap4( (uint&) x);
		ivp_byte_swap4( (uint&) y);
		ivp_byte_swap4( (uint&) z);
		ivp_byte_swap4( (uint&) w);
		}
};

#ifdef IVP_WINDOWS_ALIGN16
#pragma pack(pop)
#endif

#endif