void QuatGenMetricTest::testGenTimingSetRot() { double bokd = 1; float bokf = 1; gmtl::Quat<double> q1; const long iters(25000); for (long iter = 0; iter < iters; ++iter) { gmtl::set( q1, gmtl::makeNormal( gmtl::AxisAngled( bokd, bokd, bokd, bokd ) ) ); bokd += q1[2]; } gmtl::Quat<float> q2; bokf = 1.0f; for (long iter = 0; iter < iters; ++iter) { gmtl::set( q2, gmtl::makeNormal( gmtl::AxisAnglef( bokf, bokf, bokf, bokf ) ) ); bokf -= q2[3]; } gmtl::Quat<double> q3; bokd = 1.0f; for (long iter = 0; iter < iters; ++iter) { gmtl::set( q3, gmtl::makeNormal( gmtl::AxisAngled( bokd, gmtl::Vec<double, 3>( bokd, bokd, bokd ) ) ) ); bokd *= q3[1] + 1.2; } gmtl::Quat<float> q4; bokf = 1.0f; for (long iter = 0; iter < iters; ++iter) { gmtl::set( q4, gmtl::makeNormal( gmtl::AxisAnglef( bokf, gmtl::Vec<float, 3>( bokf, bokf, bokf ) ) ) ); bokf += q4[1] + 1.2f; } gmtl::Quat<double> q5; gmtl::Vec<double, 3> v4(1,2,3), v5(1,2,3); for (long iter = 0; iter < iters; ++iter) { gmtl::setRot( q5, gmtl::makeNormal( v4 ), gmtl::makeNormal( v5 ) ); v4[2] += q5[1] + 1.2; v5[0] -= q5[2] + 1.2; } gmtl::Quat<float> q6; gmtl::Vec<float, 3> v6(1,2,3), v7(1,2,3); for (long iter = 0; iter < iters; ++iter) { gmtl::setRot( q6, gmtl::makeNormal( v6 ), gmtl::makeNormal( v7 ) ); v6[2] += q6[1] + 1.2f; v7[0] -= q6[2] + 1.2f; } // force intelligent compilers to do all the iterations (ie. to not optimize them out), // by using the variables computed... CPPUNIT_ASSERT( bokf != 0.998f ); CPPUNIT_ASSERT( bokd != 0.0998 ); CPPUNIT_ASSERT( q1[0] != 10000.0f ); CPPUNIT_ASSERT( q2[1] != 10000.0f ); CPPUNIT_ASSERT( q3[2] != 10000.0f ); CPPUNIT_ASSERT( q4[3] != 10000.0f ); CPPUNIT_ASSERT( q5[0] != 10000.0f ); CPPUNIT_ASSERT( q6[1] != 10000.0f ); }
void test01() { CIMParamValue pv; PEGASUS_TEST_ASSERT(pv.isUninitialized()); String p1("message"); CIMValue v1(String("argument_Test")); CIMParamValue a1(p1, v1); // Test call to CIMParamValue::setValue(CIMValue& value) // this test uses the above values for a1, p1 and v1. CIMParamValue a7(p1, v1); CIMValue v7(String("argument_Test7")); a7.setValue( v7); PEGASUS_TEST_ASSERT(a1.getValue().toString() != a7.getValue().toString()); PEGASUS_TEST_ASSERT(a1.getParameterName() == a7.getParameterName()); // Test call to CIMParamValue::setParameterName(String& parameterName) // this test uses the above values for a1, p1 and v1. CIMParamValue a8(p1, v1); String p8("message8"); a8.setParameterName( p8); PEGASUS_TEST_ASSERT(a1.getValue().toString() == a8.getValue().toString()); PEGASUS_TEST_ASSERT(a1.getParameterName() != a8.getParameterName()); PEGASUS_TEST_ASSERT(a8.isTyped()); a8.setIsTyped(false); PEGASUS_TEST_ASSERT(!a8.isTyped()); String p2("message2"); CIMValue v2(String("argument_Test2")); CIMParamValue a2(p2, v2); String p3("message3"); CIMValue v3(String("argument_Test3")); CIMParamValue a3(p3, v3); String p4("message4"); CIMValue v4(String("argument_Test4")); CIMParamValue a4(p4, v4); CIMParamValue a5 = a4; String p6("message6"); CIMValue v6(String("argument_Test6")); CIMParamValue a6(p6, v6); Array<CIMParamValue> aa; aa.append(a1); aa.append(a2); aa.append(CIMParamValue("message3", CIMValue(200000))); aa.append(CIMParamValue("message4", CIMValue(String("test4")))); // // clone // CIMParamValue a4clone = a4.clone(); aa.append(a4clone); if (verbose) { for (Uint32 i=0; i< aa.size(); i++) { XmlWriter::printParamValueElement(aa[i], cout); } } // // toXml // Buffer xmlOut; XmlWriter::appendParamValueElement(xmlOut, a4clone); }
void Cube::initialize() { // Buffer Vertex Data for a Color cube GLfloat hW = 1 / 2.0f; GLfloat hH = 1 / 2.0f; GLfloat hD = 1 / 2.0f; vector<pntVertexData> v; // Vertex Positions glm::vec4 v0(-hW, -hH, hD, 1.0f); glm::vec4 v1(-hW, -hH, -hD, 1.0f); glm::vec4 v2(hW, -hH, -hD, 1.0f); glm::vec4 v3(hW, -hH, hD, 1.0f); glm::vec4 v4(-hW, hH, hD, 1.0f); glm::vec4 v5(-hW, hH, -hD, 1.0f); glm::vec4 v6(hW, hH, -hD, 1.0f); glm::vec4 v7(hW, hH, hD, 1.0f); // Create interleaved position and normal data glm::vec3 n = glm::vec3(-1, 0, 0); v.push_back(pntVertexData(v0, n, glm::vec2(0.0f, 0.0f))); v.push_back(pntVertexData(v4, n, glm::vec2(0.0f, 1.0f))); v.push_back(pntVertexData(v1, n, glm::vec2(1.0f, 0.0f))); v.push_back(pntVertexData(v1, n, glm::vec2(1.0f, 0.0f))); v.push_back(pntVertexData(v4, n, glm::vec2(0.0f, 1.0f))); v.push_back(pntVertexData(v5, n, glm::vec2(1.0f, 1.0f))); n = glm::vec3(1, 0, 0); v.push_back(pntVertexData(v3, n, glm::vec2(0.0f, 0.0f))); v.push_back(pntVertexData(v2, n, glm::vec2(1.0f, 0.0f))); v.push_back(pntVertexData(v6, n, glm::vec2(1.0f, 1.0f))); v.push_back(pntVertexData(v3, n, glm::vec2(0.0f, 0.0f))); v.push_back(pntVertexData(v6, n, glm::vec2(1.0f, 1.0f))); v.push_back(pntVertexData(v7, n, glm::vec2(0.0f, 1.0f))); n = glm::vec3(0, 0, 1); v.push_back(pntVertexData(v0, n, glm::vec2(0.0f, 1.0f))); v.push_back(pntVertexData(v3, n, glm::vec2(1.0f, 1.0f))); v.push_back(pntVertexData(v7, n, glm::vec2(1.0f, 0.0f))); v.push_back(pntVertexData(v0, n, glm::vec2(0.0f, 1.0f))); v.push_back(pntVertexData(v7, n, glm::vec2(1.0f, 0.0f))); v.push_back(pntVertexData(v4, n, glm::vec2(0.0f, 0.0f))); n = glm::vec3(0, 0, -1); v.push_back(pntVertexData(v1, n, glm::vec2(1.0f, 0.0f))); v.push_back(pntVertexData(v5, n, glm::vec2(1.0f, 1.0f))); v.push_back(pntVertexData(v2, n, glm::vec2(0.0f, 0.0f))); v.push_back(pntVertexData(v2, n, glm::vec2(0.0f, 0.0f))); v.push_back(pntVertexData(v5, n, glm::vec2(1.0f, 1.0f))); v.push_back(pntVertexData(v6, n, glm::vec2(0.0f, 1.0f))); n = glm::vec3(0, 1, 0); v.push_back(pntVertexData(v4, n, glm::vec2(0.0f, 0.0f))); v.push_back(pntVertexData(v7, n, glm::vec2(2.0f, 0.0f))); v.push_back(pntVertexData(v6, n, glm::vec2(2.0f, 2.0f))); v.push_back(pntVertexData(v4, n, glm::vec2(0.0f, 0.0f))); v.push_back(pntVertexData(v6, n, glm::vec2(2.0f, 2.0f))); v.push_back(pntVertexData(v5, n, glm::vec2(0.0f, 2.0f))); n = glm::vec3(0, -1, 0); v.push_back(pntVertexData(v0, n, glm::vec2(0.0f, 1.0f))); v.push_back(pntVertexData(v2, n, glm::vec2(2.0f, 0.0f))); v.push_back(pntVertexData(v3, n, glm::vec2(2.0f, 1.0f))); v.push_back(pntVertexData(v0, n, glm::vec2(0.0f, 1.0f))); v.push_back(pntVertexData(v1, n, glm::vec2(0.0f, 0.0f))); v.push_back(pntVertexData(v2, n, glm::vec2(2.0f, 0.0f))); glUseProgram(shaderProgram); material = Material(glGetUniformLocation(shaderProgram, "object.ambientMat"), glGetUniformLocation(shaderProgram, "object.diffuseMat"), glGetUniformLocation(shaderProgram, "object.specularMat"), glGetUniformLocation(shaderProgram, "object.specularExp"), glGetUniformLocation(shaderProgram, "object.emmissiveMat"), glGetUniformLocation(shaderProgram, "object.textureMode")); // Generate vertex array object and bind it for the first time glGenVertexArrays(1, &vertexArrayObject); glBindVertexArray(vertexArrayObject); GLuint VBO; glGenBuffers(1, &VBO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, v.size() * sizeof(pntVertexData), &v[0], GL_STATIC_DRAW); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(pntVertexData), 0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(pntVertexData), (const GLvoid*)sizeof(glm::vec4)); glEnableVertexAttribArray(1); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(pntVertexData), (const GLvoid*)(sizeof(glm::vec3)+sizeof(glm::vec4))); glEnableVertexAttribArray(2); numberOfIndices = v.size(); v.clear(); // Set the modeling transformation glm::mat4 modelingTransformation = glm::translate(glm::vec3(0.0, 0.0f, 0.0f)) * glm::rotate(M_PI / 4.0f, glm::vec3(0.0f, 1.0f, 0.0f)); GLuint modelLocation = glGetUniformLocation(shaderProgram, "modelMatrix"); assert(modelLocation != 0xFFFFFFFF); glUniformMatrix4fv(modelLocation, 1, GL_FALSE, glm::value_ptr(modelingTransformation)); }
void QuatGenMetricTest::testGenTimingMakeRot() { double bokd = 1; float bokf = 1; gmtl::Quat<double> q1; const long iters(25000); for (long iter = 0; iter < iters; ++iter) { q1 = gmtl::make<gmtl::Quat<double> >( gmtl::makeNormal( gmtl::AxisAngled( bokd, bokd, bokd, bokd ) ) ); bokd += q1[2]; } gmtl::Quat<float> q2; bokf = 1.0f; for (long iter = 0; iter < iters; ++iter) { q2 = gmtl::make<gmtl::Quat<float> >( gmtl::makeNormal( gmtl::AxisAnglef( bokf, bokf, bokf, bokf ) ) ); bokf -= q2[3]; } gmtl::Quat<double> q3; bokd = 1.0f; for (long iter = 0; iter < iters; ++iter) { q3 = gmtl::make<gmtl::Quat<double> >( gmtl::makeNormal( gmtl::AxisAngled( bokd, gmtl::Vec<double, 3>( bokd, bokd, bokd ) ) ) ); bokd *= q3[1] + 1.234; } gmtl::Quat<float> q4; bokf = 1.0f; for (long iter = 0; iter < iters; ++iter) { q4 = gmtl::make<gmtl::Quat<float> >( gmtl::makeNormal( gmtl::AxisAnglef( bokf, gmtl::Vec<float, 3>( bokf, bokf, bokf ) ) ) ); bokf += q4[1] + 1.234f; } gmtl::Quat<double> q5; gmtl::Vec<double, 3> v4(1,2,3), v5(1,2,3); for (long iter = 0; iter < iters; ++iter) { q5 = gmtl::makeRot<gmtl::Quat<double> >( gmtl::makeNormal(v4), gmtl::makeNormal(v5) ); v4[2] += q5[1] + 1.234; v5[0] -= q5[2] + 1.234; } gmtl::Quat<float> q6; gmtl::Vec<float, 3> v6(1,2,3), v7(1,2,3); for (long iter = 0; iter < iters; ++iter) { q6 = gmtl::makeRot<gmtl::Quat<float> >( gmtl::makeNormal(v6), gmtl::makeNormal(v7) ); v6[2] += q6[1] + 1.234f; v7[0] -= q6[2] + 1.234f; } gmtl::AxisAnglef axisAngle; for (long iter = 0; iter < iters; ++iter) { gmtl::set( axisAngle, q6 ); q6[0] = axisAngle[0] + axisAngle[1] - axisAngle[2] - axisAngle[3]; axisAngle[0] += q6[1] + 1.234f; axisAngle[1] -= q6[2] * -0.22f + 1.234f; axisAngle[2] += q6[1] + 0.1f; axisAngle[3] -= q6[2] - 0.99f; } // force intelligent compilers to do all the iterations (ie. to not optimize them out), // by using the variables computed... CPPUNIT_ASSERT( bokf != 0.998f ); CPPUNIT_ASSERT( bokd != 0.0998 ); CPPUNIT_ASSERT( q1[0] != 10000.0f ); CPPUNIT_ASSERT( q2[1] != 10000.0f ); CPPUNIT_ASSERT( q3[2] != 10000.0f ); CPPUNIT_ASSERT( q4[3] != 10000.0f ); CPPUNIT_ASSERT( q5[0] != 10000.0f ); CPPUNIT_ASSERT( q6[1] != 10000.0f ); }
void VectorTest::test_constructor(void) { message += "test_constructor\n"; std::string file_name = "../data/vector.dat"; // Default Vector<bool> v1; assert_true(v1.size() == 0, LOG); // Size Vector<bool> v2(1); assert_true(v2.size() == 1, LOG); // Size initialization Vector<bool> v3(1, false); assert_true(v3.size() == 1, LOG); assert_true(v3[0] == false, LOG); // File Vector<int> v4(3, 0); v4.save(file_name); Vector<int> w4(file_name); assert_true(w4.size() == 3, LOG); assert_true(w4 == 0, LOG); // Sequential Vector<int> v6(10, 5, 50); assert_true(v6.size() == 9, LOG); assert_true(v6[0] == 10, LOG); assert_true(v6[8] == 50, LOG); Vector<double> v7(3.0, 0.2, 3.8); assert_true(v7.size() == 5, LOG); assert_true(v7[0] == 3.0, LOG); assert_true(v7[4] == 3.8, LOG); Vector<int> v8(9, -1, 1); assert_true(v8.size() == 9, LOG); assert_true(v8[0] == 9, LOG); assert_true(v8[8] == 1, LOG); // Copy Vector<std::string> v5(1, "hello"); Vector<std::string> w5(v5); assert_true(w5.size() == 1, LOG); assert_true(w5[0] == "hello", LOG); }
void QhullLinkedList_test:: t_QhullLinkedList_iterator() { RboxPoints rcube("c"); Qhull q(rcube,"QR0"); // rotated unit cube QhullVertexList vs(q.endVertex(), q.endVertex()); QhullVertexListIterator i= vs; QCOMPARE(vs.count(), 0); QVERIFY(!i.hasNext()); QVERIFY(!i.hasPrevious()); i.toBack(); QVERIFY(!i.hasNext()); QVERIFY(!i.hasPrevious()); QhullVertexList vs2 = q.vertexList(); QhullVertexListIterator i2(vs2); QCOMPARE(vs2.count(), 8); i= vs2; QVERIFY(i2.hasNext()); QVERIFY(!i2.hasPrevious()); QVERIFY(i.hasNext()); QVERIFY(!i.hasPrevious()); i2.toBack(); i.toFront(); QVERIFY(!i2.hasNext()); QVERIFY(i2.hasPrevious()); QVERIFY(i.hasNext()); QVERIFY(!i.hasPrevious()); // i at front, i2 at end/back, 4 neighbors QhullVertexList vs3 = q.vertexList(); // same as vs2 QhullVertex v3(vs3.first()); QhullVertex v4= vs3.first(); QCOMPARE(v3, v4); QVERIFY(v3==v4); QhullVertex v5(v4.next()); QVERIFY(v4!=v5); QhullVertex v6(v5.next()); QhullVertex v7(v6.next()); QhullVertex v8(vs3.last()); QCOMPARE(i2.peekPrevious(), v8); i2.previous(); i2.previous(); i2.previous(); i2.previous(); QCOMPARE(i2.previous(), v7); QCOMPARE(i2.previous(), v6); QCOMPARE(i2.previous(), v5); QCOMPARE(i2.previous(), v4); QVERIFY(!i2.hasPrevious()); QCOMPARE(i.peekNext(), v4); // i.peekNext()= 1.0; // compiler error QCOMPARE(i.next(), v4); QCOMPARE(i.peekNext(), v5); QCOMPARE(i.next(), v5); QCOMPARE(i.next(), v6); QCOMPARE(i.next(), v7); i.next(); i.next(); i.next(); QCOMPARE(i.next(), v8); QVERIFY(!i.hasNext()); i.toFront(); QCOMPARE(i.next(), v4); }//t_QhullLinkedList_iterator
void CIcosahedron::init( float s ){ this->clearMesh(); float p = ((1.0 + sqrt(5.0))/2.0)*s; TVector3 v0(s,0.0,p); this->iVertices.push_back(v0); TVector3 v1(-s,0.0,p); this->iVertices.push_back(v1); TVector3 v2(s,0.0,-p); this->iVertices.push_back(v2); TVector3 v3(-s,0.0,-p); this->iVertices.push_back(v3); TVector3 v4(0.0,p,s); this->iVertices.push_back(v4); TVector3 v5(0,-p,s); this->iVertices.push_back(v5); TVector3 v6(0,p,-s); this->iVertices.push_back(v6); TVector3 v7(0.0,-p,-s); this->iVertices.push_back(v7); TVector3 v8(p,s,0.0); this->iVertices.push_back(v8); TVector3 v9(-p,s,0.0); this->iVertices.push_back(v9); TVector3 v10(p,-s,0.0); this->iVertices.push_back(v10); TVector3 v11(-p,-s,0.0); this->iVertices.push_back(v11); TTriangle t0(0,4,1); this->iTriangles.push_back(t0); TTriangle t1(0,1,5); this->iTriangles.push_back(t1); TTriangle t2(0,5,10); this->iTriangles.push_back(t2); TTriangle t3(0,10,8); this->iTriangles.push_back(t3); TTriangle t4(0,8,4); this->iTriangles.push_back(t4); TTriangle t5(4,8,6); this->iTriangles.push_back(t5); TTriangle t6(4,6,9); this->iTriangles.push_back(t6); TTriangle t7(4,9,1); this->iTriangles.push_back(t7); TTriangle t8(1,9,11); this->iTriangles.push_back(t8); TTriangle t9(1,11,5); this->iTriangles.push_back(t9); TTriangle t10(2,7,3); this->iTriangles.push_back(t10); TTriangle t11(2,3,6); this->iTriangles.push_back(t11); TTriangle t12(2,6,8); this->iTriangles.push_back(t12); TTriangle t13(2,8,10); this->iTriangles.push_back(t13); TTriangle t14(2,10,7); this->iTriangles.push_back(t14); TTriangle t15(7,10,5); this->iTriangles.push_back(t15); TTriangle t16(7,5,11); this->iTriangles.push_back(t16); TTriangle t17(7,11,3); this->iTriangles.push_back(t17); TTriangle t18(3,11,9); this->iTriangles.push_back(t18); TTriangle t19(3,9,6); this->iTriangles.push_back(t19); }
void dmz::StarfighterPluginSpaceBoxOSG::_create_box () { const String ImageName (_rc.find_file (_imgRc)); osg::ref_ptr<osg::Image> img = (ImageName ? osgDB::readImageFile (ImageName.get_buffer ()) : 0); if (img.valid ()) { osg::Geode* geode = new osg::Geode (); osg::Geometry* geom = new osg::Geometry; osg::Vec4Array* colors = new osg::Vec4Array; colors->push_back (osg::Vec4 (1.0f, 1.0f, 1.0f, 1.0f)); geom->setColorArray (colors); geom->setColorBinding (osg::Geometry::BIND_OVERALL); osg::StateSet *stateset = geom->getOrCreateStateSet (); stateset->setMode (GL_BLEND, osg::StateAttribute::ON); #if 0 osg::ref_ptr<osg::Material> material = new osg::Material; material->setEmission ( osg::Material::FRONT_AND_BACK, osg::Vec4 (1.0, 1.0, 1.0, 1.0)); stateset->setAttributeAndModes (material.get (), osg::StateAttribute::ON); #endif osg::Texture2D *tex = new osg::Texture2D (img.get ()); tex->setWrap (osg::Texture2D::WRAP_S, osg::Texture2D::REPEAT); tex->setWrap (osg::Texture2D::WRAP_T, osg::Texture2D::REPEAT); stateset->setTextureAttributeAndModes (0, tex, osg::StateAttribute::ON); stateset->setAttributeAndModes (new osg::CullFace (osg::CullFace::BACK)); osg::Vec3Array *vertices = new osg::Vec3Array; osg::Vec2Array *tcoords = new osg::Vec2Array; osg::Vec3Array* normals = new osg::Vec3Array; const float Off (_offset); osg::Vec3 v1 (-Off, -Off, -Off); osg::Vec3 v2 ( Off, -Off, -Off); osg::Vec3 v3 ( Off, Off, -Off); osg::Vec3 v4 (-Off, Off, -Off); osg::Vec3 v5 (-Off, -Off, Off); osg::Vec3 v6 ( Off, -Off, Off); osg::Vec3 v7 ( Off, Off, Off); osg::Vec3 v8 (-Off, Off, Off); osg::Vec3 n1 ( 1.0, 1.0, 1.0); osg::Vec3 n2 (-1.0, 1.0, 1.0); osg::Vec3 n3 (-1.0, -1.0, 1.0); osg::Vec3 n4 ( 1.0, -1.0, 1.0); osg::Vec3 n5 ( 1.0, 1.0, -1.0); osg::Vec3 n6 (-1.0, 1.0, -1.0); osg::Vec3 n7 (-1.0, -1.0, -1.0); osg::Vec3 n8 ( 1.0, -1.0, -1.0); n1.normalize (); n2.normalize (); n3.normalize (); n4.normalize (); n5.normalize (); n6.normalize (); n7.normalize (); n8.normalize (); // const float F1 (5.0f); // const float F2 (2.5f); const float F1 (5.0f); const float F2 (2.5f); int count = 0; // 1 vertices->push_back (v1); vertices->push_back (v2); vertices->push_back (v3); vertices->push_back (v4); tcoords->push_back (osg::Vec2 (0.0, 0.0)); tcoords->push_back (osg::Vec2 (0.0, F1)); tcoords->push_back (osg::Vec2 (F2, F1)); tcoords->push_back (osg::Vec2 (F2, 0.0)); normals->push_back (n1); normals->push_back (n2); normals->push_back (n3); normals->push_back (n4); count += 4; // 2 vertices->push_back (v4); vertices->push_back (v3); vertices->push_back (v7); vertices->push_back (v8); tcoords->push_back (osg::Vec2 (0.0, 0.0)); tcoords->push_back (osg::Vec2 (0.0, F1)); tcoords->push_back (osg::Vec2 (F2, F1)); tcoords->push_back (osg::Vec2 (F2, 0.0)); normals->push_back (n4); normals->push_back (n3); normals->push_back (n7); normals->push_back (n8); count += 4; // 3 vertices->push_back (v8); vertices->push_back (v7); vertices->push_back (v6); vertices->push_back (v5); tcoords->push_back (osg::Vec2 (0.0, 0.0)); tcoords->push_back (osg::Vec2 (0.0, F1)); tcoords->push_back (osg::Vec2 (F2, F1)); tcoords->push_back (osg::Vec2 (F2, 0.0)); normals->push_back (n8); normals->push_back (n7); normals->push_back (n6); normals->push_back (n5); count += 4; // 4 vertices->push_back (v5); vertices->push_back (v6); vertices->push_back (v2); vertices->push_back (v1); tcoords->push_back (osg::Vec2 (0.0, 0.0)); tcoords->push_back (osg::Vec2 (0.0, F1)); tcoords->push_back (osg::Vec2 (F2, F1)); tcoords->push_back (osg::Vec2 (F2, 0.0)); normals->push_back (n5); normals->push_back (n6); normals->push_back (n2); normals->push_back (n1); count += 4; // 5 vertices->push_back (v3); vertices->push_back (v2); vertices->push_back (v6); vertices->push_back (v7); tcoords->push_back (osg::Vec2 (0.0, 0.0)); tcoords->push_back (osg::Vec2 (0.0, F1)); tcoords->push_back (osg::Vec2 (F2, F1)); tcoords->push_back (osg::Vec2 (F2, 0.0)); normals->push_back (n3); normals->push_back (n2); normals->push_back (n6); normals->push_back (n7); count += 4; // 6 vertices->push_back (v1); vertices->push_back (v4); vertices->push_back (v8); vertices->push_back (v5); tcoords->push_back (osg::Vec2 (0.0, 0.0)); tcoords->push_back (osg::Vec2 (0.0, F1)); tcoords->push_back (osg::Vec2 (F2, F1)); tcoords->push_back (osg::Vec2 (F2, 0.0)); normals->push_back (n1); normals->push_back (n4); normals->push_back (n8); normals->push_back (n5); count += 4; geom->setNormalArray (normals); geom->setNormalBinding (osg::Geometry::BIND_PER_VERTEX); geom->addPrimitiveSet (new osg::DrawArrays (GL_QUADS, 0, count)); geom->setVertexArray (vertices); geom->setTexCoordArray (0, tcoords); geode->addDrawable (geom); _box = new osg::MatrixTransform (); _box->addChild (geode); } else { _log.error << "Failed to load: " << _imgRc << ":" << ImageName << endl; } }
int main() { typedef make_variant_shrink_over< boost::mpl::vector<double,float,int,bool,char> >::type r1type; BOOST_MPL_ASSERT((boost::mpl::equal<r1type ,boost::variant<double,bool,char> > )); //BOOST_MPL_ASSERT((boost::is_same<r1type ,boost::variant<double,bool,char> > )); r1type val1(1.1); std::cout << val1 << std::endl; std::cout << val1.which() << std::endl; val1='a'; std::cout << val1 << std::endl; std::cout << val1.which() << std::endl; val1=false; std::cout << val1 << std::endl; std::cout << val1.which() << std::endl; typedef make_variant_shrink_over<boost::mpl::vector<double,float,int> >::type r2type; BOOST_MPL_ASSERT((boost::mpl::equal<r2type ,double > )); BOOST_MPL_ASSERT((boost::is_same<r2type ,double > )); r2type d1=1.1,d2=2.2; d2=d1+d2; std::cout << d2 << std::endl; typedef make_variant_shrink_over<boost::mpl::vector<bool,char,std::string> >::type r3type; BOOST_MPL_ASSERT((boost::mpl::equal<r3type ,boost::variant<bool,char,std::string> > )); //BOOST_MPL_ASSERT((boost::is_same<r3type ,boost::variant<bool,charstd::string> > )); r3type v3('a'); v3="v3"; //std::cout << v3<std::string > ; std::cout << v3 << std::endl; v3=false; std::cout << v3 << std::endl; typedef make_variant_shrink_over<boost::mpl::vector<int,double,double,char,char,std::string> >::type r4type; BOOST_MPL_ASSERT((boost::mpl::equal<r4type ,boost::variant<double,char,std::string> > )); r4type v4("v4"); std::cout << v4 << std::endl; std::cout << v4.which() << std::endl; //v4=false; //std::cout << v4 << std::endl; //std::cout << v4.which() << std::endl; v4='4'; std::cout << v4 << std::endl; std::cout << v4.which() << std::endl; v4=4.44; std::cout << v4 << std::endl; std::cout << v4.which() << std::endl; // v4=4; // std::cout << v4 << std::endl; // std::cout << v4.which() << std::endl; //v4=v4+v4; #if 1 typedef make_variant_shrink_over< boost::mpl::vector<double,float,bool,char> ,generate_mpl_lambda_is_generalizable_to_from_type_order_sequence< boost::mpl::vector<bool,char,std::string> //your prefer order >::type >::type r5type; BOOST_MPL_ASSERT((boost::mpl::equal<r5type ,boost::variant<char,double,float> > )); //BOOST_MPL_ASSERT((boost::is_same<r5type ,boost::variant<char,double,float> > )); #endif #if 1 typedef make_variant_shrink_over< boost::mpl::vector<char,int>//::type ,generate_mpl_lambda_is_generalizable_to_from_type_order_sequence< boost::mpl::vector<bool,char,int> //::type //your prefer order >::type >::type r6type; BOOST_MPL_ASSERT((boost::mpl::equal<r6type ,int > )); BOOST_MPL_ASSERT((boost::is_same<r6type ,int > )); r6type i1=1,i2=2; i2=i1+i2; #endif #if 1 typedef make_variant_shrink_over< boost::mpl::vector<char,std::string,double,int> ,generate_mpl_lambda_is_generalizable_to_from_type_order_sequence< boost::mpl::vector<bool,char,int,std::string> //your prefer order >::type >::type r7type; BOOST_MPL_ASSERT((boost::mpl::equal<r7type ,boost::variant<std::string,double> > )); r7type v7("v777"); std::cout << v7 << std::endl; std::cout << v7.which() << std::endl; //assert( v7.which() == 0 ); //v7=7.7777; //boost::get<double>(v7); //boost::get<int>(v7); //std::cout << v7<double> << std::endl; #endif #if 1 typedef make_variant_shrink_over< boost::mpl::vector<float,bool,boost::rational<long> > ,generate_mpl_lambda_is_generalizable_to_from_type_order_sequence< boost::mpl::vector< bool , int , long , boost::rational<int> , boost::rational<long> > //your prefer order >::type >::type r8type; BOOST_MPL_ASSERT((boost::mpl::equal<r8type ,boost::variant<boost::rational<long> ,float> > )); #endif #if 1 typedef make_variant_shrink_over< boost::mpl::vector< int , boost::rational<int> > ,generate_mpl_lambda_is_generalizable_to_from_type_order_sequence< boost::mpl::vector< bool , int , long , boost::rational<int> , boost::rational<long> > //your prefer order >::type >::type r9type; BOOST_MPL_ASSERT((boost::is_same<r9type ,boost::rational<int> > )); #endif typedef boost::mpl::lambda<is_generalizable_to_custom<boost::mpl::_1 , boost::mpl::_2 > >::type is_generalizable_to_custom_mpl_lambda; typedef make_variant_shrink_over< boost::mpl::vector<double,float,bool,char> ,is_generalizable_to_custom_mpl_lambda >::type r10type; BOOST_MPL_ASSERT((boost::mpl::equal<r10type ,boost::variant<double,char> >)); r10type v10(10.1); std::cout << v10 << std::endl; std::cout << v10.which() << std::endl; boost::get<double>(v10); //v10=10; v10='a'; std::cout << v10 << std::endl; std::cout << v10.which() << std::endl; boost::get<char>(v10); typedef make_variant_shrink_over< boost::mpl::vector<double,float> ,is_generalizable_to_custom_mpl_lambda >::type r11type; BOOST_MPL_ASSERT((boost::is_same<r11type ,double > )); }
void QuatGenMetricTest::testGenTimingSetRot() { double bokd = 1; float bokf = 1; gmtl::Quat<double> q1; const long iters(25000); CPPUNIT_METRIC_START_TIMING(); for (long iter = 0; iter < iters; ++iter) { gmtl::set( q1, gmtl::makeNormal( gmtl::AxisAngled( bokd, bokd, bokd, bokd ) ) ); bokd += q1[2]; } CPPUNIT_METRIC_STOP_TIMING(); CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatd,axisangled)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10% gmtl::Quat<float> q2; bokf = 1.0f; CPPUNIT_METRIC_START_TIMING(); for (long iter = 0; iter < iters; ++iter) { gmtl::set( q2, gmtl::makeNormal( gmtl::AxisAnglef( bokf, bokf, bokf, bokf ) ) ); bokf -= q2[3]; } CPPUNIT_METRIC_STOP_TIMING(); CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatf,axisanglef)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10% gmtl::Quat<double> q3; bokd = 1.0f; CPPUNIT_METRIC_START_TIMING(); for (long iter = 0; iter < iters; ++iter) { gmtl::set( q3, gmtl::makeNormal( gmtl::AxisAngled( bokd, gmtl::Vec<double, 3>( bokd, bokd, bokd ) ) ) ); bokd *= q3[1] + 1.2; } CPPUNIT_METRIC_STOP_TIMING(); CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatd,axisangled(r,vec))", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10% gmtl::Quat<float> q4; bokf = 1.0f; CPPUNIT_METRIC_START_TIMING(); for (long iter = 0; iter < iters; ++iter) { gmtl::set( q4, gmtl::makeNormal( gmtl::AxisAnglef( bokf, gmtl::Vec<float, 3>( bokf, bokf, bokf ) ) ) ); bokf += q4[1] + 1.2f; } CPPUNIT_METRIC_STOP_TIMING(); CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatf,axisanglef(r,vec))", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10% gmtl::Quat<double> q5; gmtl::Vec<double, 3> v4(1,2,3), v5(1,2,3); CPPUNIT_METRIC_START_TIMING(); for (long iter = 0; iter < iters; ++iter) { gmtl::setRot( q5, gmtl::makeNormal( v4 ), gmtl::makeNormal( v5 ) ); v4[2] += q5[1] + 1.2; v5[0] -= q5[2] + 1.2; } CPPUNIT_METRIC_STOP_TIMING(); CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatd,vec3d,vec3d)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10% gmtl::Quat<float> q6; gmtl::Vec<float, 3> v6(1,2,3), v7(1,2,3); CPPUNIT_METRIC_START_TIMING(); for (long iter = 0; iter < iters; ++iter) { gmtl::setRot( q6, gmtl::makeNormal( v6 ), gmtl::makeNormal( v7 ) ); v6[2] += q6[1] + 1.2f; v7[0] -= q6[2] + 1.2f; } CPPUNIT_METRIC_STOP_TIMING(); CPPUNIT_ASSERT_METRIC_TIMING_LE( "QuatGenTest/setRot(quatf,vec3f,vec3f)", iters, 0.075f, 0.1f); // warn at 7.5%, error at 10% // force intelligent compilers to do all the iterations (ie. to not optimize them out), // by using the variables computed... CPPUNIT_ASSERT( bokf != 0.998f ); CPPUNIT_ASSERT( bokd != 0.0998 ); CPPUNIT_ASSERT( q1[0] != 10000.0f ); CPPUNIT_ASSERT( q2[1] != 10000.0f ); CPPUNIT_ASSERT( q3[2] != 10000.0f ); CPPUNIT_ASSERT( q4[3] != 10000.0f ); CPPUNIT_ASSERT( q5[0] != 10000.0f ); CPPUNIT_ASSERT( q6[1] != 10000.0f ); }
//---------------------------------------------------------------------------- void BspNodes::CreateScene () { // Create the scene graph. // // 1. The rectangles represent the BSP planes of the BSP tree. They // share a VertexColor3Effect. You can see a plane from either side // (backface culling disabled). The planes do not interfere with view // of the solid objects (wirestate enabled). // // 2. The sphere, tetrahedron, and cube share a TextureEffect. These // objects are convex. The backfacing triangles are discarded // (backface culling enabled). The front facing triangles are drawn // correctly by convexity, so depthbuffer reads are disabled and // depthbuffer writes are enabled. The BSP-based sorting of objects // guarantees that front faces of convex objects in the foreground // are drawn after the front faces of convex objects in the background, // which allows us to set the depthbuffer state as we have. That is, // BSPNode sorts from back to front. // // 3. The torus has backface culling enabled and depth buffering enabled. // This is necessary, because the torus is not convex. // // 4. Generally, if all objects are opaque, then you want to draw from // front to back with depth buffering fully enabled. You need to // reverse-order the elements of the visible set before drawing. If // any of the objects are semitransparent, then drawing back to front // is the correct order to handle transparency. However, you do not // get the benefit of early z-rejection for opaque objects. A better // BSP sorter needs to be built to produce a visible set with opaque // objects listed first (front-to-back order) and semitransparent // objects listed last (back-to-front order). // // scene // ground // bsp0 // bsp1 // bsp3 // torus // rectangle3 // sphere // rectangle1 // tetrahedron // rectangle0 // bsp2 // cube // rectangle2 // octahedron mScene = new0 Node(); // Create the ground. It covers a square with vertices (1,1,0), (1,-1,0), // (-1,1,0), and (-1,-1,0). Multiply the texture coordinates by a factor // to enhance the wrap-around. VertexFormat* vformat = VertexFormat::Create(2, VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0, VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0); StandardMesh sm(vformat); VertexBufferAccessor vba; TriMesh* ground = sm.Rectangle(2, 2, 16.0f, 16.0f); vba.ApplyTo(ground); for (int i = 0; i < vba.GetNumVertices(); ++i) { Float2& tcoord = vba.TCoord<Float2>(0, i); tcoord[0] *= 128.0f; tcoord[1] *= 128.0f; } std::string path = Environment::GetPathR("Horizontal.wmtf"); Texture2D* texture = Texture2D::LoadWMTF(path); ground->SetEffectInstance(Texture2DEffect::CreateUniqueInstance(texture, Shader::SF_LINEAR_LINEAR, Shader::SC_REPEAT, Shader::SC_REPEAT)); mScene->AttachChild(ground); // Partition the region above the ground into 5 convex pieces. Each plane // is perpendicular to the ground (not required generally). VertexColor3Effect* vceffect = new0 VertexColor3Effect(); vceffect->GetCullState(0, 0)->Enabled = false; vceffect->GetWireState(0, 0)->Enabled = true; Vector2f v0(-1.0f, 1.0f); Vector2f v1(1.0f, -1.0f); Vector2f v2(-0.25f, 0.25f); Vector2f v3(-1.0f, -1.0f); Vector2f v4(0.0f, 0.0f); Vector2f v5(1.0f, 0.5f); Vector2f v6(-0.75f, -7.0f/12.0f); Vector2f v7(-0.75f, 0.75f); Vector2f v8(1.0f, 1.0f); BspNode* bsp0 = CreateNode(v0, v1, vceffect, Float3(1.0f, 0.0f, 0.0f)); BspNode* bsp1 = CreateNode(v2, v3, vceffect, Float3(0.0f, 0.5f, 0.0f)); BspNode* bsp2 = CreateNode(v4, v5, vceffect, Float3(0.0f, 0.0f, 1.0f)); BspNode* bsp3 = CreateNode(v6, v7, vceffect, Float3(0.0f, 0.0f, 0.0f)); bsp0->AttachPositiveChild(bsp1); bsp0->AttachNegativeChild(bsp2); bsp1->AttachPositiveChild(bsp3); // Attach an object in each convex region. float height = 0.1f; Vector2f center; TriMesh* mesh; // The texture effect for the convex objects. Texture2DEffect* cvxeffect = new0 Texture2DEffect(Shader::SF_LINEAR_LINEAR); cvxeffect->GetDepthState(0, 0)->Enabled = false; cvxeffect->GetDepthState(0, 0)->Writable = true; // The texture effect for the torus. Texture2DEffect* toreffect = new0 Texture2DEffect(Shader::SF_LINEAR_LINEAR); // The texture image shared by the objects. path = Environment::GetPathR("Flower.wmtf"); texture = Texture2D::LoadWMTF(path); // Region 0: Create a torus mesh. mesh = sm.Torus(16, 16, 1.0f, 0.25f); mesh->SetEffectInstance(toreffect->CreateInstance(texture)); mesh->LocalTransform.SetUniformScale(0.1f); center = (v2 + v6 + v7)/3.0f; mesh->LocalTransform.SetTranslate(APoint(center[0], center[1], height)); bsp3->AttachPositiveChild(mesh); // Region 1: Create a sphere mesh. mesh = sm.Sphere(32, 16, 1.0f); mesh->SetEffectInstance(cvxeffect->CreateInstance(texture)); mesh->LocalTransform.SetUniformScale(0.1f); center = (v0 + v3 + v6 + v7)/4.0f; mesh->LocalTransform.SetTranslate(APoint(center[0], center[1], height)); bsp3->AttachNegativeChild(mesh); // Region 2: Create a tetrahedron. mesh = sm.Tetrahedron(); mesh->SetEffectInstance(cvxeffect->CreateInstance(texture)); mesh->LocalTransform.SetUniformScale(0.1f); center = (v1 + v2 + v3)/3.0f; mesh->LocalTransform.SetTranslate(APoint(center[0], center[1], height)); bsp1->AttachNegativeChild(mesh); // Region 3: Create a hexahedron (cube). mesh = sm.Hexahedron(); mesh->SetEffectInstance(cvxeffect->CreateInstance(texture)); mesh->LocalTransform.SetUniformScale(0.1f); center = (v1 + v4 + v5)/3.0f; mesh->LocalTransform.SetTranslate(APoint(center[0], center[1], height)); bsp2->AttachPositiveChild(mesh); // Region 4: Create an octahedron. mesh = sm.Octahedron(); mesh->SetEffectInstance(cvxeffect->CreateInstance(texture)); mesh->LocalTransform.SetUniformScale(0.1f); center = (v0 + v4 + v5 + v8)/4.0f; mesh->LocalTransform.SetTranslate(APoint(center[0], center[1], height)); bsp2->AttachNegativeChild(mesh); mScene->AttachChild(bsp0); }
osg::Drawable *ReverseTileNode::createReverseTile(void) const { // Get the tile ReverseTile* tile = static_cast<ReverseTile*>(_lego); // Get tile color QColor color = tile->getColor(); // Get integer sizes int width = tile->getWidth(); int length = tile->getLength(); int height = 3; // Get real position, according to tile size double mw = (-width)*Lego::length_unit/2; double pw = (width)*Lego::length_unit/2; double mwp = (-width+2)*Lego::length_unit/2; double ml = (-length)*Lego::length_unit/2; double pl = (length)*Lego::length_unit/2; double mh = (-height)*Lego::height_unit/2; double ph = (height)*Lego::height_unit/2; double phm = (height-1)*Lego::height_unit/2; // Create 14 vertices osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array; osg::Vec3 v0(mw, ml, mh); osg::Vec3 v1(mw, pl, mh); osg::Vec3 v2(mwp, pl, mh); osg::Vec3 v3(mwp, ml, mh); osg::Vec3 v4(pw, ml, phm); osg::Vec3 v5(pw, pl, phm); osg::Vec3 v6(pw, pl, ph); osg::Vec3 v7(pw, ml, ph); osg::Vec3 v8(mw, ml, ph); osg::Vec3 v9(mw, pl, ph); osg::Vec3 v10(mwp, ml, phm); osg::Vec3 v11(mwp, ml, ph); osg::Vec3 v12(mwp, pl, ph); osg::Vec3 v13(mwp, pl, phm); // Create 10 faces, 8 faces are quads splitted into two triangles // NB: Down face is transparent, we don't even create it // Front face t1 vertices->push_back(v4); vertices->push_back(v5); vertices->push_back(v6); // Front face t2 vertices->push_back(v4); vertices->push_back(v6); vertices->push_back(v7); // Back face t1 vertices->push_back(v0); vertices->push_back(v1); vertices->push_back(v8); // Back face t2 vertices->push_back(v1); vertices->push_back(v8); vertices->push_back(v9); // Top face t1 vertices->push_back(v6); vertices->push_back(v7); vertices->push_back(v9); // Top face t2 vertices->push_back(v7); vertices->push_back(v8); vertices->push_back(v9); // Slop face t1 vertices->push_back(v2); vertices->push_back(v3); vertices->push_back(v5); // Slop face t2 vertices->push_back(v3); vertices->push_back(v4); vertices->push_back(v5); // Right triangle face vertices->push_back(v2); vertices->push_back(v13); vertices->push_back(v5); // Right quad face t1 vertices->push_back(v13); vertices->push_back(v12); vertices->push_back(v6); // Right quad face t2 vertices->push_back(v13); vertices->push_back(v6); vertices->push_back(v5); // Right quad face down t1 vertices->push_back(v1); vertices->push_back(v9); vertices->push_back(v12); // Right quad face down t2 vertices->push_back(v1); vertices->push_back(v2); vertices->push_back(v12); // Left triangle face vertices->push_back(v3); vertices->push_back(v4); vertices->push_back(v10); // Left quad face t1 vertices->push_back(v4); vertices->push_back(v10); vertices->push_back(v11); // Left quad face t2 vertices->push_back(v4); vertices->push_back(v7); vertices->push_back(v11); // Left quad face down t1 vertices->push_back(v0); vertices->push_back(v3); vertices->push_back(v8); // Left quad face down t2 vertices->push_back(v3); vertices->push_back(v8); vertices->push_back(v11); // Create tile geometry osg::ref_ptr<osg::Geometry> tileGeometry = new osg::Geometry; // Match vertices tileGeometry->setVertexArray(vertices); // Add color (each rectangle has the same color except for the down one which is transparent) osg::Vec4 osgColor(static_cast<float>(color.red())/255.0, static_cast<float>(color.green())/255.0, static_cast<float>(color.blue())/255.0, 1.0); osg::ref_ptr<osg::Vec4Array> colors = new osg::Vec4Array; // Every face has the same color, so there is only one color colors->push_back(osgColor); // Match color tileGeometry->setColorArray(colors); tileGeometry->setColorBinding(osg::Geometry::BIND_OVERALL); // Create normals osg::ref_ptr<osg::Vec3Array> normals = new osg::Vec3Array; normals->push_back(osg::Vec3(1, 0, 0)); normals->push_back(osg::Vec3(1, 0, 0)); normals->push_back(osg::Vec3(-1, 0, 0)); normals->push_back(osg::Vec3(-1, 0, 0)); normals->push_back(osg::Vec3(0, 0, 1)); normals->push_back(osg::Vec3(0, 0, 1)); double w = pw - mwp; double h = phm - mh; double norm = std::sqrt(w*w + h*h); normals->push_back(osg::Vec3(h/norm, 0, -w/norm)); normals->push_back(osg::Vec3(h/norm, 0, -w/norm)); normals->push_back(osg::Vec3(0, 1, 0)); normals->push_back(osg::Vec3(0, 1, 0)); normals->push_back(osg::Vec3(0, 1, 0)); normals->push_back(osg::Vec3(0, 1, 0)); normals->push_back(osg::Vec3(0, 1, 0)); normals->push_back(osg::Vec3(0, -1, 0)); normals->push_back(osg::Vec3(0, -1, 0)); normals->push_back(osg::Vec3(0, -1, 0)); normals->push_back(osg::Vec3(0, -1, 0)); normals->push_back(osg::Vec3(0, -1, 0)); // Match normals tileGeometry->setNormalArray(normals); tileGeometry->setNormalBinding(osg::Geometry::BIND_PER_PRIMITIVE); // Define tile 18 GL_TRIANGLES with 20*3 vertices tileGeometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::TRIANGLES, 0, 18*3)); // Return the tile whithout plot return tileGeometry.release(); }
osg::Drawable *ClampNode::createBrick(void) const { // Get the brick Clamp* clamp = static_cast<Clamp*>(_lego); // Get brick color QColor color = clamp->getColor(); // Get clamp bounding box clamp->calculateBoundingBox(); BoundingBox bb = clamp->getBoundingBox(); // Get integer sizes int width = bb.getWidth(); int length = bb.getLength(); int height = bb.getHeight(); // Get real position, according to tile size double mw = (-width)*Lego::length_unit/2; double mwpm = (-width)*Lego::length_unit/2+Lego::height_unit/2; double mwp = (-width)*Lego::length_unit/2+0.93*Lego::height_unit; double pw = (width)*Lego::length_unit/2; double pwm = (width)*Lego::length_unit/2-Lego::height_unit/2; double ml = (-length)*Lego::length_unit/2; double mlp = (-length+0.5)*Lego::length_unit/2; double pl = (length)*Lego::length_unit/2; double plm = (length-0.5)*Lego::length_unit/2; double mh = (-height)*Lego::height_unit/2; double mhp = (-height)*Lego::height_unit/2+2*Lego::plot_top_height; double mhpm = (-height)*Lego::height_unit/2+Lego::plot_top_height; double phm = (height)*Lego::height_unit/2-Lego::height_unit/2; double phmp = (height)*Lego::height_unit/2-0.5*Lego::height_unit/2; // Create 3 vertices osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array; osg::Vec3 v0(ml, mw, mh); osg::Vec3 v1(pl, mw, mh); osg::Vec3 v2(pl, pw, mh); osg::Vec3 v3(ml, pw, mh); osg::Vec3 v4(ml, pw, mhp); osg::Vec3 v5(pl, pw, mhp); osg::Vec3 v6(pl, mw, mhp); osg::Vec3 v7(ml, mw, mhp); osg::Vec3 v8(mlp, mw, mhp); osg::Vec3 v9(mlp, mw, phm); osg::Vec3 v10(ml, mw, phm); osg::Vec3 v11(ml, mwp, phmp); osg::Vec3 v12(mlp, mwp, phmp); osg::Vec3 v13(mlp, pw, mhp); osg::Vec3 v14(plm, mw, mhp); osg::Vec3 v15(plm, mw, phm); osg::Vec3 v16(pl, mw, phm); osg::Vec3 v17(pl, mwp, phmp); osg::Vec3 v18(plm, mwp, phmp); osg::Vec3 v19(plm, pw, mhp); osg::Vec3 v20(mlp, mwpm, mh); osg::Vec3 v21(plm, mwpm, mh); osg::Vec3 v22(plm, pwm, mh); osg::Vec3 v23(mlp, pwm, mh); osg::Vec3 v24(mlp, mwpm, mhpm); osg::Vec3 v25(plm, mwpm, mhpm); osg::Vec3 v26(plm, pwm, mhpm); osg::Vec3 v27(mlp, pwm, mhpm); // Create 1 faces, 0 faces are quads splitted into two triangles // NB: Down face is transparent, we don't even create it // Bottom vertices->push_back(v3); vertices->push_back(v2); vertices->push_back(v1); vertices->push_back(v0); // Bottom hole vertices->push_back(v20); vertices->push_back(v21); vertices->push_back(v22); vertices->push_back(v23); // Bottom far vertices->push_back(v24); vertices->push_back(v25); vertices->push_back(v26); vertices->push_back(v27); // Front face vertices->push_back(v2); vertices->push_back(v3); vertices->push_back(v4); vertices->push_back(v5); // Back face vertices->push_back(v0); vertices->push_back(v1); vertices->push_back(v6); vertices->push_back(v7); // Left bottom face vertices->push_back(v0); vertices->push_back(v3); vertices->push_back(v4); vertices->push_back(v7); // Right bottom face vertices->push_back(v1); vertices->push_back(v2); vertices->push_back(v5); vertices->push_back(v6); // Top face vertices->push_back(v4); vertices->push_back(v5); vertices->push_back(v6); vertices->push_back(v7); // Left part back vertices->push_back(v7); vertices->push_back(v8); vertices->push_back(v9); vertices->push_back(v10); // Left part left ext vertices->push_back(v4); vertices->push_back(v7); vertices->push_back(v10); vertices->push_back(v11); // Left part front vertices->push_back(v4); vertices->push_back(v11); vertices->push_back(v12); vertices->push_back(v13); // Left part left int vertices->push_back(v8); vertices->push_back(v9); vertices->push_back(v12); vertices->push_back(v13); // Right part back vertices->push_back(v6); vertices->push_back(v14); vertices->push_back(v15); vertices->push_back(v16); // Left part left ext vertices->push_back(v5); vertices->push_back(v6); vertices->push_back(v16); vertices->push_back(v17); // Left part front vertices->push_back(v5); vertices->push_back(v17); vertices->push_back(v18); vertices->push_back(v19); // Left part left int vertices->push_back(v14); vertices->push_back(v15); vertices->push_back(v18); vertices->push_back(v19); // Bottom front vertices->push_back(v20); vertices->push_back(v21); vertices->push_back(v25); vertices->push_back(v24); // Bottom right vertices->push_back(v21); vertices->push_back(v22); vertices->push_back(v26); vertices->push_back(v25); // Bottom back vertices->push_back(v22); vertices->push_back(v23); vertices->push_back(v27); vertices->push_back(v26); // Bottom left vertices->push_back(v23); vertices->push_back(v20); vertices->push_back(v24); vertices->push_back(v27); // Create tile geometry osg::ref_ptr<osg::Geometry> clampGeometry = new osg::Geometry; // Match vertices clampGeometry->setVertexArray(vertices); // Create colors osg::Vec4 osgColor(static_cast<float>(color.red())/255.0, static_cast<float>(color.green())/255.0, static_cast<float>(color.blue())/255.0, 1.0); osg::ref_ptr<osg::Vec4Array> colors = new osg::Vec4Array; // Every face has the same color, so there is only one color colors->push_back(osgColor); // Match color clampGeometry->setColorArray(colors); clampGeometry->setColorBinding(osg::Geometry::BIND_OVERALL); // Create normals osg::ref_ptr<osg::Vec3Array> normals = new osg::Vec3Array; normals->push_back(osg::Vec3(0, 0, -1)); normals->push_back(osg::Vec3(0, 0, -1)); normals->push_back(osg::Vec3(0, 1, 0)); normals->push_back(osg::Vec3(0, -1, 0)); normals->push_back(osg::Vec3(-1, 0, 0)); normals->push_back(osg::Vec3(1, 0, 0)); normals->push_back(osg::Vec3(0, 0, 1)); normals->push_back(osg::Vec3(0, -1, 0)); normals->push_back(osg::Vec3(-1, 0, 0)); double w = pw - mwp; double h = phmp - mhp; double norm = std::sqrt(w*w + h*h); normals->push_back(osg::Vec3(0, h/norm, w/norm)); normals->push_back(osg::Vec3(1, 0, 0)); normals->push_back(osg::Vec3(0, -1, 0)); normals->push_back(osg::Vec3(1, 0, 0)); normals->push_back(osg::Vec3(0, h/norm, w/norm)); normals->push_back(osg::Vec3(-1, 0, 0)); normals->push_back(osg::Vec3(0, 1, 0)); normals->push_back(osg::Vec3(-1, 0, 0)); normals->push_back(osg::Vec3(0, -1, 0)); normals->push_back(osg::Vec3(1, 0, 0)); // Match normals clampGeometry->setNormalArray(normals); clampGeometry->setNormalBinding(osg::Geometry::BIND_PER_PRIMITIVE); // Define 1 GL_QUADS with 1*4 vertices, corresponding to bottom part clampGeometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS, 0*4, 4)); // Define 1 GL_QUADS with 1*4 vertices, corresponding to 1 hole in bottom part clampGeometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS, 1*4, 4)); // Retesslate to create hole osgUtil::Tessellator tesslator; tesslator.setTessellationType(osgUtil::Tessellator::TESS_TYPE_GEOMETRY); tesslator.setWindingType(osgUtil::Tessellator::TESS_WINDING_ODD); tesslator.retessellatePolygons(*clampGeometry); // Create 17 GL_QUADS, i.e. 18*4 vertices clampGeometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS, 2*4, 18*4)); // Return the tile whithout plot return clampGeometry.release(); }
void test_n_voronoi(void) { std::vector<Vector> pos; real L = 32; Vector a, b, c, d; a.x = 1.; a.y = 2.; b.x = 2.; b.y = 2.; c.x = 2.; c.y = 0.; d.x = 4.; d.y = 4.; pos = {a, b, c, d}; MATRIX n(4, 4); n.Zero(); calculate_n_voronoi(n, pos, L); MATRIX m(4, 4); /* 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0 */ m.Set(0, 0, 0); m.Set(0, 1, 1); m.Set(0, 2, 1); m.Set(0, 3, 1); m.Set(1, 0, 1); m.Set(1, 1, 0); m.Set(1, 2, 1); m.Set(1, 3, 1); m.Set(2, 0, 1); m.Set(2, 1, 1); m.Set(2, 2, 0); m.Set(2, 3, 1); m.Set(3, 0, 1); m.Set(3, 1, 1); m.Set(3, 2, 1); m.Set(3, 3, 0); assert(n == m); /*9 particles Voronoi*/ MATRIX n2(9, 9); n2.Zero(); Vector v1(10,30), v2(20,30), v3(30,30), v4(10,20), v5(20,20), v6(30,20), v7(10,10), v8(20,10), v9(30,10); pos = {v1, v2, v3, v4, v5, v6, v7, v8, v9}; calculate_n_voronoi(n2, pos, L); MATRIX m2(9, 9); /* 0 1 1 1 0 0 1 0 0 1 0 1 0 1 0 0 1 0 1 1 0 0 0 1 0 0 1 1 0 0 0 1 1 1 0 0 0 1 0 1 0 1 0 1 0 0 0 1 1 1 0 0 0 1 1 0 0 1 0 0 0 1 1 0 1 0 0 1 0 1 0 1 0 0 1 0 0 1 1 1 0 */ m2.Set(0, 0, 0);m2.Set(0, 1, 1);m2.Set(0, 2, 1);m2.Set(0, 3, 1);m2.Set(0, 4, 0);m2.Set(0, 5, 0);m2.Set(0, 6, 1);m2.Set(0, 7, 0);m2.Set(0, 8, 0); m2.Set(1, 0, 1);m2.Set(1, 1, 0);m2.Set(1, 2, 1);m2.Set(1, 3, 0);m2.Set(1, 4, 1);m2.Set(1, 5, 0);m2.Set(1, 6, 0);m2.Set(1, 7, 1);m2.Set(1, 8, 0); m2.Set(2, 0, 1);m2.Set(2, 1, 1);m2.Set(2, 2, 0);m2.Set(2, 3, 0);m2.Set(2, 4, 0);m2.Set(2, 5, 1);m2.Set(2, 6, 0);m2.Set(2, 7, 0);m2.Set(2, 8, 1); m2.Set(3, 0, 1);m2.Set(3, 1, 0);m2.Set(3, 2, 0);m2.Set(3, 3, 0);m2.Set(3, 4, 1);m2.Set(3, 5, 1);m2.Set(3, 6, 1);m2.Set(3, 7, 0);m2.Set(3, 8, 0); m2.Set(4, 0, 0);m2.Set(4, 1, 1);m2.Set(4, 2, 0);m2.Set(4, 3, 1);m2.Set(4, 4, 0);m2.Set(4, 5, 1);m2.Set(4, 6, 0);m2.Set(4, 7, 1);m2.Set(4, 8, 0); m2.Set(5, 0, 0);m2.Set(5, 1, 0);m2.Set(5, 2, 1);m2.Set(5, 3, 1);m2.Set(5, 4, 1);m2.Set(5, 5, 0);m2.Set(5, 6, 0);m2.Set(5, 7, 0);m2.Set(5, 8, 1); m2.Set(6, 0, 1);m2.Set(6, 1, 0);m2.Set(6, 2, 0);m2.Set(6, 3, 1);m2.Set(6, 4, 0);m2.Set(6, 5, 0);m2.Set(6, 6, 0);m2.Set(6, 7, 1);m2.Set(6, 8, 1); m2.Set(7, 0, 0);m2.Set(7, 1, 1);m2.Set(7, 2, 0);m2.Set(7, 3, 0);m2.Set(7, 4, 1);m2.Set(7, 5, 0);m2.Set(7, 6, 1);m2.Set(7, 7, 0);m2.Set(7, 8, 1); m2.Set(8, 0, 0);m2.Set(8, 1, 0);m2.Set(8, 2, 1);m2.Set(8, 3, 0);m2.Set(8, 4, 0);m2.Set(8, 5, 1);m2.Set(8, 6, 1);m2.Set(8, 7, 1);m2.Set(8, 8, 0); assert(n2 == m2); }
/** * Test constructing and destructing a vector */ void TestVector::TestConstructor() { // Plain Old Data //--------------- // Default constructor Vector<int> v1; AssertEquals(0u, v1.Size()); // Fill constructor Vector<int> v2(3u); AssertEquals(3u, v2.Size()); AssertEquals(3u, v2.Capacity()); for(uint i = 0; i < 3; ++i) { AssertEquals(0, v2[i]); } // Fill constructor with value Vector<int> v3(3u, 3); AssertEquals(3u, v3.Size()); AssertEquals(3u, v3.Capacity()); for(uint i = 0; i < 3; ++i) { AssertEquals(3, v3[i]); } // Copy constructor Vector<int> v4(v3); AssertEquals(3u, v4.Size()); AssertEquals(3u, v4.Capacity()); for(uint i = 0; i < 3; ++i) { AssertEquals(3, v4[i]); } // Assignment Vector<int> v5 = v4; AssertEquals(3u, v5.Size()); AssertEquals(3u, v5.Capacity()); for(uint i = 0; i < 3; ++i) { AssertEquals(3, v5[i]); } // Class //------ // Default simple object SimpleClass c1 = SimpleClass(); SimpleClass c2 = SimpleClass(1, 2); // Default constructor Vector<SimpleClass> v6; AssertEquals(0u, v6.Size()); // Fill constructor Vector<SimpleClass> v7(3u); AssertEquals(3u, v7.Size()); AssertEquals(3u, v7.Capacity()); for(uint i = 0; i < 3; ++i) { AssertEquals(c1, v7[i]); } // Fill constructor with value Vector<SimpleClass> v8(3u, c2); AssertEquals(3u, v8.Size()); AssertEquals(3u, v8.Capacity()); for(uint i = 0; i < 3; ++i) { AssertEquals(c2, v8[i]); } // Copy constructor Vector<SimpleClass> v9(v8); AssertEquals(3u, v9.Size()); AssertEquals(3u, v9.Capacity()); for(uint i = 0; i < 3; ++i) { AssertEquals(c2, v9[i]); } // Assignment Vector<SimpleClass> v10 = v9; AssertEquals(3u, v10.Size()); AssertEquals(3u, v10.Capacity()); for(uint i = 0; i < 3; ++i) { AssertEquals(c2, v10[i]); } }
void TestTupleList() { test_db_config::DbConfig config; bool bRet = config.Init(); assert( bRet == true ); occiwrapper::ConnectionInfo info( config.GetStrIp(), 1521, config.GetUserName(), config.GetPassword(), config.GetSid() ); occiwrapper::SessionFactory sf; occiwrapper::Session s = sf.Create( info ); string strErrMsg; struct tm objTm; objTm.tm_year = 2014 - 1900; objTm.tm_mon = 11; objTm.tm_mday = 30; objTm.tm_hour = 10; objTm.tm_min = 43; objTm.tm_sec = 0; s << strCreateTable, now, bRet, strErrMsg; // test 1 elements s << "truncate table tbl_test_tuple_elements", now, bRet, strErrMsg; assert( bRet ); tuple< int > t1[ 2 ]; t1[ 0 ] = make_tuple( 1 ); t1[ 1 ] = make_tuple( 2 ); list< tuple< int > > v1( t1, t1 + 2 ); s << "insert into tbl_test_tuple_elements( t1 ) values ( :1 )", batched_use( v1 ), now, bRet, strErrMsg; assert( bRet ); list< tuple< int > > v1Out; s << "select t1 from tbl_test_tuple_elements", into( v1Out ), now, bRet, strErrMsg; assert( bRet ); assert( v1Out.size() == 2 ); // test 2 elements s << "truncate table tbl_test_tuple_elements", now, bRet, strErrMsg; assert( bRet ); tuple< int, float > t2[ 2 ]; t2[ 0 ] = make_tuple( 1, 1.1 ); t2[ 1 ] = make_tuple( 2, 2.1 ); list< tuple< int, float > > v2( t2, t2 + 2 ); s << "insert into tbl_test_tuple_elements( t1, t2 ) values ( :1, :2 )", batched_use( v2 ), now, bRet, strErrMsg; assert( bRet ); list< tuple< int, float > > v2Out; s << "select t1, t2 from tbl_test_tuple_elements", into( v2Out ), now, bRet, strErrMsg; assert( bRet ); assert( v2Out.size() == 2 ); // test 3 elements s << "truncate table tbl_test_tuple_elements", now, bRet, strErrMsg; assert( bRet ); tuple< int, float, string > t3[ 2 ]; t3[ 0 ] = make_tuple( 1, 1.1, "str1" ); t3[ 1 ] = make_tuple( 2, 2.1, "str2" ); list< tuple< int, float, string > > v3( t3, t3 + 2 ); s << "insert into tbl_test_tuple_elements( t1, t2, t3 ) values ( :1, :2, :3 )", batched_use( v3 ), now, bRet, strErrMsg; assert( bRet ); list< tuple< int, float, string > > v3Out; s << "select t1, t2, t3 from tbl_test_tuple_elements", into( v3Out ), now, bRet, strErrMsg; assert( bRet ); assert( v3Out.size() == 2 ); // test 4 elements s << "truncate table tbl_test_tuple_elements", now, bRet, strErrMsg; assert( bRet ); tuple< int, float, string, struct tm > t4[ 2 ]; t4[ 0 ] = make_tuple( 1, 1.1, "str1", objTm ); t4[ 1 ] = make_tuple( 2, 2.1, "str2", objTm ); list< tuple< int, float, string, struct tm > > v4( t4, t4 + 2 ); s << "insert into tbl_test_tuple_elements( t1, t2, t3, t4 ) values ( :1, :2, :3, :4 )", batched_use( v4 ), now, bRet, strErrMsg; assert( bRet ); list< tuple< int, float, string, struct tm > > v4Out; s << "select t1, t2, t3, t4 from tbl_test_tuple_elements", into( v4Out ), now, bRet, strErrMsg; assert( bRet ); assert( v4Out.size() == 2 ); // test 5 elements s << "truncate table tbl_test_tuple_elements", now, bRet, strErrMsg; assert( bRet ); tuple< int, float, string, struct tm, struct tm > t5[ 2 ]; t5[ 0 ] = make_tuple( 1, 1.1, "str1", objTm, objTm ); t5[ 1 ] = make_tuple( 2, 2.1, "str2", objTm, objTm ); list< tuple< int, float, string, struct tm, struct tm > > v5( t5, t5 + 2 ); s << "insert into tbl_test_tuple_elements( t1, t2, t3, t4, t5 ) values ( :1, :2, :3, :4, :5 )", batched_use( v5 ), now, bRet, strErrMsg; assert( bRet ); list< tuple< int, float, string, struct tm, struct tm > > v5Out; s << "select t1, t2, t3, t4, t5 from tbl_test_tuple_elements", into( v5Out ), now, bRet, strErrMsg; assert( bRet ); assert( v5Out.size() == 2 ); // test 6 elements s << "truncate table tbl_test_tuple_elements", now, bRet, strErrMsg; assert( bRet ); tuple< int, float, string, struct tm, struct tm, double > t6[ 2 ]; t6[ 0 ] = make_tuple( 1, 1.1, "str1", objTm, objTm, 1.2 ); t6[ 1 ] = make_tuple( 2, 2.1, "str2", objTm, objTm, 2.2 ); list< tuple< int, float, string, struct tm, struct tm, double > > v6( t6, t6 + 2 ); s << "insert into tbl_test_tuple_elements( t1, t2, t3, t4, t5, t6 ) values ( :1, :2, :3, :4, :5, :6 )", batched_use( v6 ), now, bRet, strErrMsg; assert( bRet ); list< tuple< int, float, string, struct tm, struct tm, double > > v6Out; s << "select t1, t2, t3, t4, t5, t6 from tbl_test_tuple_elements", into( v6Out ), now, bRet, strErrMsg; assert( bRet ); assert( v6Out.size() == 2 ); // test 7 element s << "truncate table tbl_test_tuple_elements", now, bRet, strErrMsg; assert( bRet ); tuple< int, float, string, struct tm, struct tm, double, double > t7[ 2 ]; t7[ 0 ] = make_tuple( 1, 1.1, "str1", objTm, objTm, 1.2, 3.1 ); t7[ 1 ] = make_tuple( 2, 2.1, "str2", objTm, objTm, 2.2, 3.2 ); list< tuple< int, float, string, struct tm, struct tm, double, double > > v7( t7, t7 + 2 ); s << "insert into tbl_test_tuple_elements( t1, t2, t3, t4, t5, t6, t7 ) values ( :1, :2, :3, :4, :5, :6, :7 )", batched_use( v7 ), now, bRet, strErrMsg; assert( bRet ); list< tuple< int, float, string, struct tm, struct tm, double, double > > v7Out; s << "select t1, t2, t3, t4, t5, t6, t7 from tbl_test_tuple_elements", into( v7Out ), now, bRet, strErrMsg; assert( bRet ); assert( v7Out.size() == 2 ); // test 8 element s << "truncate table tbl_test_tuple_elements", now, bRet, strErrMsg; assert( bRet ); tuple< int, float, string, struct tm, struct tm, double, double, string > t8[ 2 ]; t8[ 0 ] = make_tuple( 1, 1.1, "str1", objTm, objTm, 1.2, 3.1, "str8_1" ); t8[ 1 ] = make_tuple( 2, 2.1, "str2", objTm, objTm, 2.2, 3.2, "str8_2" ); list< tuple< int, float, string, struct tm, struct tm, double, double, string > > v8( t8, t8 + 2 ); s << "insert into tbl_test_tuple_elements( t1, t2, t3, t4, t5, t6, t7, t8 ) values ( :1, :2, :3, :4, :5, :6, :7, :8 )", batched_use( v8 ), now, bRet, strErrMsg; assert( bRet ); list< tuple< int, float, string, struct tm, struct tm, double, double, string > > v8Out; s << "select t1, t2, t3, t4, t5, t6, t7, t8 from tbl_test_tuple_elements", into( v8Out ), now, bRet, strErrMsg; assert( bRet ); assert( v8Out.size() == 2 ); // test 9 element s << "truncate table tbl_test_tuple_elements", now, bRet, strErrMsg; assert( bRet ); tuple< int, float, string, struct tm, struct tm, double, double, string, string > t9[ 2 ]; t9[ 0 ] = make_tuple( 1, 1.1, "str1", objTm, objTm, 1.2, 3.1, "str8_1", "str9_1" ); t9[ 1 ] = make_tuple( 2, 2.1, "str2", objTm, objTm, 2.2, 3.2, "str8_2", "str9_2" ); list< tuple< int, float, string, struct tm, struct tm, double, double, string, string > > v9( t9, t9 + 2 ); s << "insert into tbl_test_tuple_elements( t1, t2, t3, t4, t5, t6, t7, t8, t9 ) values ( :1, :2, :3, :4, :5, :6, :7, :8, :9 )", batched_use( v9 ), now, bRet, strErrMsg; assert( bRet ); list< tuple< int, float, string, struct tm, struct tm, double, double, string, string > > v9Out; s << "select t1, t2, t3, t4, t5, t6, t7, t8, t9 from tbl_test_tuple_elements", into( v9Out ), now, bRet, strErrMsg; assert( bRet ); assert( v9Out.size() == 2 ); // test 10 element s << "truncate table tbl_test_tuple_elements", now, bRet, strErrMsg; assert( bRet ); tuple< int, float, string, struct tm, struct tm, double, double, string, string, string > t10[ 2 ]; t10[ 0 ] = make_tuple( 1, 1.1, "str1", objTm, objTm, 1.2, 3.1, "str8_1", "str9_1", "str10_1" ); t10[ 1 ] = make_tuple( 2, 2.1, "str2", objTm, objTm, 2.2, 3.2, "str8_2", "str9_2", "str10_2" ); list< tuple< int, float, string, struct tm, struct tm, double, double, string, string, string > > v10( t10, t10 + 2 ); s << "insert into tbl_test_tuple_elements( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10 ) values ( :1, :2, :3, :4, :5, :6, :7, :8, :9, :10 )", batched_use( v10 ), now, bRet, strErrMsg; assert( bRet ); list< tuple< int, float, string, struct tm, struct tm, double, double, string, string, string > > v10Out; s << "select t1, t2, t3, t4, t5, t6, t7, t8, t9, t10 from tbl_test_tuple_elements", into( v10Out ), now, bRet, strErrMsg; assert( bRet ); assert( v10Out.size() == 2 ); s << "drop table tbl_test_tuple_elements", now, bRet, strErrMsg; assert( bRet ); }
int testVector() { int numErr = 0; logMessage(_T("TESTING - class GM_3dVector ...\n\n")); // Default constructor, vector must be invalid GM_3dVector v; if (v.isValid()) { logMessage(_T("\tERROR - Default constructor creates valid vector\n")); numErr++; } else { logMessage(_T("\tOK - Default constructor creates invalid vector\n")); } // Get/Set vector coordinates double x = getRandomDouble(); double y = getRandomDouble(); double z = getRandomDouble(); v.x(x); v.y(y); v.z(z); if (!v.isValid() || v.x() != x || v.y() != y || v.z() != z) { logMessage(_T("\tERROR - Get/Set not working\n")); numErr++; } else { logMessage(_T("\tOK - Get/Set working\n")); } // Copy constructor GM_3dVector v1(v); if (v.isValid() != v1.isValid() || v1.x() != v.x() || v1.y() != v.y() || v1.z() != v.z()) { logMessage(_T("\tERROR - Copy constructor not working\n")); numErr++; } else { logMessage(_T("\tOK - Copy constructor working\n")); } // Constructor (point) GM_3dPoint pt(getRandomDouble(), getRandomDouble(), getRandomDouble()); GM_3dVector v2(pt); if (!v2.isValid() || v2.x() != pt.x() || v2.y() != pt.y() || v2.z() != pt.z()) { logMessage(_T("\tERROR - Constructor from point not working\n")); numErr++; } else { logMessage(_T("\tOK - Constructor from point working\n")); } // Constructor (line) GM_3dLine line(getRandomDouble(), getRandomDouble(), getRandomDouble(), getRandomDouble(), getRandomDouble(), getRandomDouble()); GM_3dVector v3(line); if (!v3.isValid() || v3.x() != line.end().x() - line.begin().x() || v3.y() != line.end().y() - line.begin().y() || v3.z() != line.end().z() - line.begin().z()) { logMessage(_T("\tERROR - Constructor from line not working\n")); numErr++; } else { logMessage(_T("\tOK - Constructor from line working\n")); } // Constructor (angle) double ang = getRandomAngle(); GM_3dVector v4(ang); if (!v4.isValid() || v4.x() != cos(ang) || v4.y() != sin(ang) || v4.z() != 0.0) { logMessage(_T("\tERROR - XY angle constructor not working\n")); numErr++; } else { logMessage(_T("\tOK - XY angle constructor working\n")); } // Module double module = v.mod(); if (module != sqrt(v.x()*v.x() + v.y()*v.y() + v.z()*v.z())) { logMessage(_T("\tERROR - Module computation not working\n")); numErr++; } else { logMessage(_T("\tOK - Module computation working\n")); } // Normalization v.normalize(); if (fabs(v.mod()-1.0) > GM_NULL_TOLERANCE) { logMessage(_T("\tERROR - Normalization not working\n")); numErr++; } else { logMessage(_T("\tOK - Normalization working\n")); } // xy Angle double checkAng = v4.xyAngle(); if (checkAng > GM_PI) { checkAng -= 2.0 * GM_PI; } if (fabs(checkAng - ang) > GM_NULL_TOLERANCE) { logMessage(_T("\tERROR - xy angle computation not working\n")); numErr++; } else { logMessage(_T("\tOK - xy angle computation working\n")); } // Angle between vectors ang = getRandomAngle(); GM_3dVector v5(ang); GM_3dVector baseVect(0.0); checkAng = baseVect.xyAngle(v5); if (checkAng > GM_PI) { checkAng -= 2.0 * GM_PI; } double checkAng1 = v5.xyAngle(baseVect); if (checkAng1 > GM_PI) { checkAng1 -= 2.0 * GM_PI; } if (fabs(checkAng - ang) > GM_NULL_TOLERANCE || fabs(-checkAng1 - ang) > GM_NULL_TOLERANCE) { logMessage(_T("\tERROR - Angle between vectors computation not working\n")); numErr++; } else { logMessage(_T("\tOK - Angle between vectors computation working\n")); } // At left ang = getRandomAngle(); if (ang < 0.0) { ang = 2.0 * GM_PI + ang; } double ang1 = getRandomAngle(); if (ang1 < 0.0) { ang1 = 2.0 * GM_PI + ang1; } GM_3dVector v6(ang); GM_3dVector v7(ang1); bool v6AtLeftv7 = v6.isAtLeftOnXY(v7); bool v7AtLeftv6 = v7.isAtLeftOnXY(v6); double checkv6Ang = v6.xyAngle(); double checkv7Ang = v7.xyAngle(); bool checkv6AtLeftv7 = ang > ang1 ? true : false; if (fabs(ang - checkv6Ang) > GM_NULL_TOLERANCE || fabs(ang1 - checkv7Ang) > GM_NULL_TOLERANCE || checkv6AtLeftv7 != v6AtLeftv7 || v6AtLeftv7 == v7AtLeftv6) { logMessage(_T("\tERROR - At left not working\n")); numErr++; } else { logMessage(_T("\tOK - At left working\n")); } // Dot product GM_3dVector v8(getRandomDouble(), getRandomDouble(), getRandomDouble()); GM_3dVector v9(getRandomDouble(), getRandomDouble(), getRandomDouble()); double dotProd = v8 * v9; double dotProd1 = v9 * v8; double checkDotProd = v8.x()*v9.x() + v8.y()*v9.y() + v8.z()*v9.z(); if (dotProd != checkDotProd || dotProd1 != checkDotProd) { logMessage(_T("\tERROR - Dot product not working\n")); numErr++; } else { logMessage(_T("\tOK - Dot product working\n")); } // Cross product GM_3dVector crossProd = v8 ^ v9; GM_3dVector crossProd1 = v9 ^ v8; double checkCrossProdX = v8.y()*v9.z() - v8.z()*v9.y(); double checkCrossProdY = v8.z()*v9.x() - v8.x()*v9.z(); double checkCrossProdZ = v8.x()*v9.y() - v8.y()*v9.x(); if (crossProd.x() != checkCrossProdX || crossProd.y() != checkCrossProdY || crossProd.z() != checkCrossProdZ || crossProd1.x() != -checkCrossProdX || crossProd1.y() != -checkCrossProdY || crossProd1.z() != -checkCrossProdZ) { logMessage(_T("\tERROR - Cross product not working\n")); numErr++; } else { logMessage(_T("\tOK - Cross product working\n")); } // Scale double factor = getRandomDouble(); GM_3dVector v8Scaled = v8 * factor; if (v8Scaled.x() != v8.x()*factor || v8Scaled.y() != v8.y()*factor || v8Scaled.z() != v8.z()*factor) { logMessage(_T("\tERROR - Scaling not working\n")); numErr++; } else { logMessage(_T("\tOK - Scaling working\n")); } // Sum GM_3dVector sum = v8 + v9; if (sum.x() != v8.x()+v9.x() || sum.y() != v8.y()+v9.y() || sum.z() != v8.z()+v9.z()) { logMessage(_T("\tERROR - Sum not working\n")); numErr++; } else { logMessage(_T("\tOK - Sum working\n")); } // Difference GM_3dVector diff = v8 - v9; if (diff.x() != v8.x()-v9.x() || diff.y() != v8.y()-v9.y() || diff.z() != v8.z()-v9.z()) { logMessage(_T("\tERROR - Difference not working\n")); numErr++; } else { logMessage(_T("\tOK - Difference working\n")); } return numErr; }