예제 #1
0
TEST(Vector, shouldNormalize) {

  Vector v(2, 2, 2);

  VECTOR_EQUAL( 0.577350,0.577350,0.577350, v.normalize() );
  VECTOR_EQUAL( 0.577350,0.577350,0.577350, v );
}
예제 #2
0
TEST(Vector, shouldProvideSubtractionOperator) {

  Vector v1(1,2,3);
  Vector v2(1,1,1);

  VECTOR_EQUAL( 0, 1, 2, (v1 - v2) );
  Vector v3 = v2 -= v1;
  VECTOR_EQUAL( 0, -1, -2, v2 );
  VECTOR_EQUAL( 0, -1, -2, v3 );
  
}
예제 #3
0
TEST(Vector, shouldProvideMultiplyByScalar) {

  Vector v(1, 2, 3);
  
  VECTOR_EQUAL( 3, 6, 9, (v * 3) );

  Vector actual = (v *= 2);
  VECTOR_EQUAL( 2, 4, 6, actual );
  VECTOR_EQUAL( 2, 4, 6, v );

}
예제 #4
0
TEST(Vector, shouldProvideAddOperators) {

  Vector v1(1,-3,0);
  Vector v2(4, 4, 2);
  
  VECTOR_EQUAL( 5, 1, 2, (v1+v2));

  Vector v3 = v1 += v2;
  VECTOR_EQUAL( 5, 1, 2, v1);
  VECTOR_EQUAL( 5, 1, 2, v3);

}
예제 #5
0
TEST(RTPolySet, boundingBoxShouldBeUnionOfTriangles) {

  RTPolySet ps;
  RTTriangle t1(Vector(0,0,0), Vector(1,0,0), Vector(1,0,1));
  ps.addTriangle(t1);
  RTTriangle t2(Vector(5,5,5), Vector(6,6,5), Vector(6,6,6));
  ps.addTriangle(t2);

  BoundingBox box = ps.getBoundingBox();

  VECTOR_EQUAL(0,0,0, box.getOrigin());
  VECTOR_EQUAL(6,6,6, box.getDelta());

}
inline TYPE VECTOR_CMOV( TYPE a, TYPE b, TYPE c, TYPE d){
    TYPE z = VECTOR_EQUAL  ( a, b );
//    return _mm_blendv_epi8( d, c, z );
    TYPE g = VECTOR_AND   ( c, z );
    TYPE h = VECTOR_ANDNOT( z, d );
    return VECTOR_OR         ( g, h );
}
예제 #7
0
TEST(Vector, shouldProvideUnaryMinus) {

  Vector v(1,-3,0);
  
  VECTOR_EQUAL( -1, 3, 0, (-v));

}
예제 #8
0
TEST(Vector, shouldProvideTreeValueConstructor) {

  Vector v(5, 6, 1);

  VECTOR_EQUAL( 5, 6, 1, v );

}
예제 #9
0
TEST(Vector, shouldProvideCrossProduct) {

  Vector v1(5, 4, 2);
  Vector v2(1, 3, 4);

  VECTOR_EQUAL(10, -18, 11, v1.cross(v2) );

}
예제 #10
0
TEST(Vector, shouldHaveTreeComponentArrayConstructor) {
  float values[] { 1,2,3 };
  Vector v(values);

  VECTOR_EQUAL( 1, 2, 3, v);

  
}
예제 #11
0
TEST(Vector, shouldRotateAndHomogenize) {

  Vector v( 0, 1, 0 );

  v.rotate( X, M_PI );

  VECTOR_EQUAL( 0, -1, 0, v );

}
예제 #12
0
TEST(Matrix, normalizeShouldHandleNullLength) {

  Matrix m1(0,0,0);
  m1.normalize();

  VECTOR_EQUAL(0,0,0, m1);
  

}
예제 #13
0
TEST(Matrix, shouldProvideHadamardProduct) {
  
	Matrix m1(1, 2, 3);

  Matrix r = m1.hadamardProduct(m1);

  VECTOR_EQUAL(1, 4, 9, r);
  
}
예제 #14
0
TEST(Matrix, shouldProvideUnaryMinus) {

  Matrix m(1,0,-3);

  Matrix actual = -m;

  VECTOR_EQUAL(-1, 0, 3, actual);
  
}
예제 #15
0
TEST(Matrix, shouldBeMultipliableWithVector) {

  Matrix m(4,4);
  float vals[] = {
    1,1,1,1,
    2,2,2,2,
    3,3,3,3,
    4,4,4,4
  };
  m.setAll(vals);

  Vector v( 1, 2, 3 );
  Vector r = m * v;

  float l = 4+8+12;
  VECTOR_EQUAL( (1+2+3)/l, (2+4+6)/l, (3+6+9)/l, r ); 

}
예제 #16
0
TEST(Vector, shouldSupportUnaryMinus) {

  Vector v(1, 2, 3);
  VECTOR_EQUAL( - 1, -2, -3, -v);

}