ivu_linear_ps2.hxx

hl2 source code. Do not use it illegal.

// Copyright (C) Ipion Software GmbH 1999-2000. All rights reserved.

//IVP_EXPORT_PROTECTED


#ifndef WIN32
#	pragma interface
#endif



#if 1


inline void IVP_U_Float_Point::set_negative(const IVP_U_Float_Point *p_source){
    IVP_DOUBLE a = p_source->k[0];
    IVP_DOUBLE b = p_source->k[1];	a = -a;
    IVP_DOUBLE c = p_source->k[2];	b = -b;
                                c = -c;
    k[0]= (IVP_FLOAT)a;
    k[1]= (IVP_FLOAT)b;
    k[2]= (IVP_FLOAT)c;
}


inline void IVP_U_Float_Point::mult(IVP_DOUBLE factor){
    IVP_DOUBLE a,b,c;
    a = k[0] * factor;
    b = k[1] * factor;
    c = k[2] * factor;
    k[0] = (IVP_FLOAT)a; k[1] = (IVP_FLOAT)b; k[2] = (IVP_FLOAT)c;
}



inline void IVP_U_Float_Point::set_pairwise_mult (const IVP_U_Float_Point *v1, const IVP_U_Float_Point *v2){	// pairwise multiple 
    IVP_DOUBLE a,b,c;
    a = v1->k[0] * v2->k[0];
    b = v1->k[1] * v2->k[1];
    c = v1->k[2] * v2->k[2];

    k[0] = a;
    k[1] = b;
    k[2] = c;
}


inline void IVP_U_Float_Point::add(const IVP_U_Float_Point *v1, const IVP_U_Float_Point *v2){
    IVP_DOUBLE a = v1->k[0] + v2->k[0];
    IVP_DOUBLE b = v1->k[1] + v2->k[1];
    IVP_DOUBLE c = v1->k[2] + v2->k[2];
    k[0] = (IVP_FLOAT)a;k[1] = (IVP_FLOAT)b;k[2] = (IVP_FLOAT)c;  
}


inline void IVP_U_Float_Point::subtract(const IVP_U_Float_Point *v1,const IVP_U_Float_Point *v2){
    IVP_DOUBLE a,b,c;
    a = v1->k[0] - v2->k[0];
    b = v1->k[1] - v2->k[1];
    c = v1->k[2] - v2->k[2];

    k[0] = (IVP_FLOAT)a;
    k[1] = (IVP_FLOAT)b;
    k[2] = (IVP_FLOAT)c;
}



inline IVP_DOUBLE IVP_U_Float_Point::quad_length() const {
    return (k[0]*k[0] + k[1]*k[1] + k[2]*k[2]);
}


#else



inline void IVP_U_Float_Point::set_negative(const IVP_U_Float_Point *p_source){
    IVP_DOUBLE a = p_source->k[0];
    IVP_DOUBLE b = p_source->k[1];	a = -a;
    IVP_DOUBLE c = p_source->k[2];	b = -b;
                                c = -c;
    k[0]= (IVP_FLOAT)a;
    k[1]= (IVP_FLOAT)b;
    k[2]= (IVP_FLOAT)c;
}


inline void IVP_U_Float_Point::mult(IVP_DOUBLE factor){
 	asm __volatile__("
	lqc2    vf4,0x0(%0)
        mfc1    $8,%1
        qmtc2    $8,vf5
	vmulx.xyzw	vf6,vf4,vf5
	sqc2    vf6,0x0(%0)
	": : "r" (this) , "f" (factor):"$8");
}


inline void IVP_U_Float_Point::set_pairwise_mult (const IVP_U_Float_Point *v1, const IVP_U_Float_Point *v2){	// pairwise multiple 
	asm __volatile__("
	lqc2    vf4,0x0(%1)
	lqc2    vf5,0x0(%2)
	vmul.xyz	vf6,vf4,vf5
	sqc2    vf6,0x0(%0)
	": : "r" (this) , "r" (v1), "r" (v2));
}


inline void IVP_U_Float_Point::add(const IVP_U_Float_Point *v1, const IVP_U_Float_Point *v2){
	asm __volatile__("
	lqc2     vf4,0x0(%1)
	lqc2     vf5,0x0(%2)
	vadd.xyz vf6,vf4,vf5
	sqc2     vf6,0x0(%0)
	": : "r" (this) , "r" (v1), "r" (v2));
}



inline void IVP_U_Float_Point::subtract(const IVP_U_Float_Point *v1,const IVP_U_Float_Point *v2){
	asm __volatile__("
	lqc2    vf4,0x0(%1)
	lqc2    vf5,0x0(%2)
	vsub.xyz	vf6,vf4,vf5
	sqc2    vf6,0x0(%0)
	"
	: /*no output*/
	: "r" (this) , "r" (v1), "r" (v2)
	: "memory");
}


inline IVP_DOUBLE IVP_U_Float_Point::quad_length() const {
    return (k[0]*k[0] + k[1]*k[1] + k[2]*k[2]);
}

}
#endif



inline IVP_DOUBLE IVP_U_Float_Point::quad_distance_to(const IVP_U_Float_Point *p)const{
#if 1
    IVP_DOUBLE a = k[0] - p->k[0];
    IVP_DOUBLE b = k[1] - p->k[1];
    IVP_DOUBLE c = k[2] - p->k[2];
    a *=a; b*= b; c*=c;
    return a+b+c;
#else
    register float ret;
	asm __volatile__("
	lqc2    vf4,0x0(%1)
	lqc2    vf5,0x0(%2)
	vsub.xyz vf5,vf4,vf4
	vmul.xyz vf5,vf5,vf5
	vaddy.x vf5,vf5,vf5
	vaddz.x vf5,vf5,vf5
	qmfc2   $2 ,vf5
	mtc1    $2,%0
	"
	: "=r" (ret) 
	:"r" (this) ,"r" (p) 
	:"$2", "memory" );
	return ret;
#endif
}


inline void IVP_U_Float_Point::set_to_zero() {
	asm __volatile__("
	sqc2    vf0,0x0(%0)
	"
	:/*no output*/
	: "r" (this)
	: "memory" );
}

inline void IVP_U_Float_Point::set(const IVP_U_Float_Point *p_source){
#if 0
    IVP_DOUBLE a = p_source->k[0];
    IVP_DOUBLE b = p_source->k[1];
    IVP_DOUBLE c = p_source->k[2];
    k[0]= (IVP_FLOAT)a;
    k[1]= (IVP_FLOAT)b;
    k[2]= (IVP_FLOAT)c;
#else
	asm __volatile__("
	lqc2    vf4,0x0(%1)
	sqc2    vf4,0x0(%0)
	"
	: /* no output */
	: "r" (this) , "r" (p_source)
	: "memory");
#endif
}


inline void IVP_U_Float_Point::add_multiple (const IVP_U_Float_Point *v1, const IVP_U_Float_Point *v2, IVP_DOUBLE factor2){	// vektor addition
#if 0
    IVP_DOUBLE a,b,c;

    a = v2->k[0] * factor2;
    b = v2->k[1] * factor2;    a += v1->k[0];
    c = v2->k[2] * factor2;    b += v1->k[1];
                               c += v1->k[2];
    k[0] = a;
    k[1] = b;
    k[2] = c;
#else
    asm __volatile__("
	lqc2    vf4,0x0(%2)
        mfc1    $8,%3
        qmtc2    $8,vf5
	vmulx.xyz vf6,vf4,vf5

	lqc2    vf4,0x0(%1)
	vadd.xyz vf6,vf4,vf6
	sqc2    vf6,0x0(%0)
	"
	: /* no output */
	: "r" (this), "r" (v1) , "r" (v2), "f" (factor2)
	: "$8" , "memory");
#endif
}


inline IVP_DOUBLE IVP_U_Float_Point::dot_product(const IVP_U_Float_Point *v2) const {
#if 1
        return( k[0]*v2->k[0] + k[1]*v2->k[1] + k[2]*v2->k[2] );
#else
	register float ret;
	asm __volatile__("
	lqc2    vf4,0x0(%1)
	lqc2    vf5,0x0(%2)
	vmul.xyz vf5,vf4,vf5
	vaddy.x vf5,vf5,vf5
	vaddz.x vf5,vf5,vf5
	qmfc2   $2 ,vf5
	mtc1    $2,%0
	": "=r" (ret) :"r" (this) ,"r" (v2) :"$2" );
	return ret;
#endif
};

inline void IVP_U_Float_Point::set_multiple(const IVP_U_Float_Point *v, IVP_DOUBLE f){
#if 0
    IVP_DOUBLE a = v->k[0] * f;
    IVP_DOUBLE b = v->k[1] * f;
    IVP_DOUBLE c = v->k[2] * f;
    k[0]= (IVP_FLOAT)a;
    k[1]= (IVP_FLOAT)b;
    k[2]= (IVP_FLOAT)c;
#else
 	asm __volatile__("
	lqc2    vf4,0x0(%1)
        mfc1    $8,%2
        qmtc2    $8,vf5
	vmulx.xyz	vf6,vf4,vf5
	sqc2    vf6,0x0(%0)
	"
	: /* no output */
	: "r" (this) , "r" (v), "f" (f):
	"$8", "memory");
#endif
}


inline void IVP_U_Float_Point::inline_subtract_and_mult(const IVP_U_Float_Point *v1,const IVP_U_Float_Point *v2, IVP_DOUBLE factor){	// vektor addition
#if 0
    IVP_DOUBLE a,b,c;
    a = (v1->k[0] - v2->k[0]);
    b = (v1->k[1] - v2->k[1]);	a *= factor;
    c = (v1->k[2] - v2->k[2]);	b *= factor;
    c *=factor;
    k[0] = a;
    k[1] = b;
    k[2] = c;
#else
    asm __volatile__("
	lqc2    vf4,0x0(%1)
	lqc2    vf6,0x0(%2)
	vsub.xyz vf4, vf4,vf6
        mfc1    $8,%3
        qmtc2    $8,vf5
	vmulx.xyz vf6,vf4,vf5
	sqc2    vf6,0x0(%0)
	"
	: /* no output */
	: "r" (this), "r" (v1) , "r" (v2), "f" (factor)
	:"$8", "memory");
#endif
}


//////////////////////////////////////////////////////////////////////

inline IVP_DOUBLE IVP_U_Hesse::get_dist(const IVP_U_Float_Point *p) const {
    return this->dot_product(p) + hesse_val;
}

inline IVP_DOUBLE IVP_U_Float_Hesse::get_dist(const IVP_U_Float_Point *p) const {
    return this->dot_product(p) + hesse_val;
}


void IVP_U_Matrix3::inline_vimult3( const IVP_U_Float_Point *p_in, IVP_U_Float_Point * p_out ) const{
#if 0
    IVP_DOUBLE a = get_elem(0,0)*p_in->k[0] + get_elem(1,0)*p_in->k[1] + get_elem(2,0)*p_in->k[2];
    IVP_DOUBLE b = get_elem(0,1)*p_in->k[0] + get_elem(1,1)*p_in->k[1] + get_elem(2,1)*p_in->k[2];
    IVP_DOUBLE c = get_elem(0,2)*p_in->k[0] + get_elem(1,2)*p_in->k[1] + get_elem(2,2)*p_in->k[2];
	p_out->k[0] = (IVP_FLOAT)a;p_out->k[1] = (IVP_FLOAT)b; p_out->k[2] = (IVP_FLOAT)c;
#else
	asm __volatile__("
	lqc2    vf8,0x0(%2)
	lqc2    vf4,0x0(%1)
	vmulax.xyz	ACC,   vf4,vf8
	lqc2    vf5,0x10(%1)